@openapi-flow/core 0.2.0 → 0.3.0

package/dist/types/api-selection-evidence.js

@@ -0,0 +1 @@
+export {};

package/dist/types/binding-validation-internal.d.ts

@@ -0,0 +1,12 @@
+import type { ApiBindingMaterial } from './api-bindings.js';
+import type { NativeOutputContract } from './node-output.js';
+import type { OutputBinding } from './api-arguments.js';
+export interface ApiBindingSourceRegistry {
+    api: Map<string, ApiBindingMaterial>;
+    native: Map<string, NativeOutputContract>;
+}
+export interface ValidateRegisteredApiBindingInput {
+    callId: string;
+    binding: OutputBinding;
+    registry: ApiBindingSourceRegistry;
+}

package/dist/types/binding-validation-internal.js

@@ -0,0 +1 @@
+export {};

package/dist/types/deferred-api-inputs.d.ts

@@ -0,0 +1,45 @@
+import type { ApiOperationKey } from './api-catalog.js';
+import type { ApiCallArguments, JsonValue } from './api-arguments.js';
+import type { InspectApiArgumentRequirementsInput } from './api-clarification.js';
+import type { BindingSchema } from './api-bindings.js';
+/** A declared input location, never a fake value in the API request. */
+export interface DeferredApiInputSlot {
+    kind: 'api-request-input';
+    state: 'deferred';
+    id: string;
+    callId: string;
+    operation: ApiOperationKey;
+    targetPointer: string;
+    requestedInputs?: string[];
+    schema: BindingSchema;
+    openapiVersion: string;
+    operationSummary?: string;
+    parameterDescription?: string;
+}
+export type DeferredApiInputMaterial = InspectApiArgumentRequirementsInput;
+export type DeferredApiInputValues = Record<string, JsonValue>;
+export interface CollectDeferredApiInputSlotsInput {
+    materials: DeferredApiInputMaterial[];
+}
+export interface InspectDeferredApiInputsInput extends CollectDeferredApiInputSlotsInput {
+    inputValues: DeferredApiInputValues;
+}
+export interface DeferredApiInputIssue {
+    code: 'missing-input' | 'unknown-input' | 'invalid-value';
+    inputId: string;
+    callId?: string;
+    targetPointer?: string;
+    message: string;
+}
+export interface ResolvedDeferredApiInputs {
+    status: 'ready';
+    slots: DeferredApiInputSlot[];
+    arguments: ApiCallArguments[];
+    issues: DeferredApiInputIssue[];
+}
+export interface PendingDeferredApiInputs {
+    status: 'needs-input' | 'invalid-input';
+    slots: DeferredApiInputSlot[];
+    issues: DeferredApiInputIssue[];
+}
+export type DeferredApiInputInspection = ResolvedDeferredApiInputs | PendingDeferredApiInputs;

package/dist/types/deferred-api-inputs.js

@@ -0,0 +1 @@
+export {};

package/dist/types/json-input-assignment.d.ts

@@ -0,0 +1,9 @@
+import type { JsonValue, JsonValueObject } from './api-arguments.js';
+import type { RequestContainerKind } from './api-bindings.js';
+export interface AssignJsonInputValueInput {
+    values: JsonValueObject;
+    pointer: string;
+    value: JsonValue;
+    containerKind: (pointer: string) => RequestContainerKind;
+    source: string;
+}

package/dist/types/json-input-assignment.js

@@ -0,0 +1 @@
+export {};

package/dist/types/native-instance-dependencies.d.ts

@@ -0,0 +1,35 @@
+import type { NativeSelectedPlanningInput, NativeInstanceSelectionContext, SelectedNativeInstance, PreparedNativeNodeMaterial } from './native-node-planning.js';
+import type { NativeOutputContract } from './node-output.js';
+export interface NativeInstanceDependencyChoice {
+    sourceNodeIds: string[];
+    reason?: string;
+}
+export interface NativeInstanceDependencyProposal {
+    sourcesByNodeId: Record<string, NativeInstanceDependencyChoice>;
+}
+export interface NativeInstanceDependencyContext {
+    selectionId: string;
+    scenario: string;
+    instances: SelectedNativeInstance[];
+    capabilities: NativeInstanceSelectionContext['capabilities'];
+    apiMaterials: NativeInstanceSelectionContext['apiMaterials'];
+    preparedNativeNodes: PreparedNativeNodeMaterial[];
+    preparedOutputs: NativeOutputContract[];
+    sourceCandidatesByNodeId: Record<string, string[]>;
+}
+export interface NativeInstanceDependencyPlan {
+    id: string;
+    selectionId: string;
+    context: NativeInstanceDependencyContext;
+    proposal: NativeInstanceDependencyProposal;
+}
+export interface ResolveNativeInstanceDependenciesInput extends NativeSelectedPlanningInput {
+    proposal: NativeInstanceDependencyProposal;
+}
+export interface ValidateNativeInstanceDependenciesInput extends NativeSelectedPlanningInput {
+    dependencies: NativeInstanceDependencyPlan;
+}
+export interface NativeNodeConfigurationDependencies {
+    planId: string;
+    sourceNodeIds: string[];
+}

package/dist/types/native-instance-dependencies.js

@@ -0,0 +1 @@
+export {};

package/dist/types/native-material-snapshot.d.ts

@@ -0,0 +1,44 @@
+import type { ApiBindingMaterial } from './api-bindings.js';
+import type { NativeOutputContract } from './node-output.js';
+import type { WorkflowCapability, PlannedNativeNode } from './workflow-plan.js';
+/** Authoritative data contracts for one material revision; no compiled node names. */
+export interface WorkflowNativeMaterialSources {
+    apiMaterials: ApiBindingMaterial[];
+    nativeOutputs: NativeOutputContract[];
+}
+export interface WorkflowNativeMaterialRequirement {
+    field: keyof WorkflowNativeMaterialSources;
+    minimumItems: number;
+}
+export interface MissingWorkflowNativeMaterialRequirement extends WorkflowNativeMaterialRequirement {
+    availableItems: number;
+}
+export interface ResolveNativeMaterialSnapshotInput extends WorkflowNativeMaterialSources {
+    nativeNodes: PlannedNativeNode[];
+    capabilities: WorkflowCapability[];
+    /** Explicit unfinished reference decisions, never inferred successful output contracts. */
+    deferredNodeIds: string[];
+    /** Code-owned edit scheduling may defer a consumer once its actual upstream contracts are known. */
+    shouldDeferNode?: (nodeId: string, availableOutputs: NativeOutputContract[], resolvedNodeIds: string[]) => boolean;
+}
+export interface BoundNativeMaterialNode {
+    nodeId: string;
+    capability: WorkflowCapability;
+}
+export interface PendingNativeMaterialNode {
+    nodeId: string;
+    capability: string;
+    kind: 'deferred-reference' | 'unavailable-source';
+    sourceNodeIds: string[];
+}
+export interface NativeMaterialSnapshotFields {
+    bindings: BoundNativeMaterialNode[];
+    outputs: NativeOutputContract[];
+    pending: PendingNativeMaterialNode[];
+}
+export type NativeMaterialSnapshot = NativeMaterialSnapshotFields & ({
+    status: 'ready';
+    capabilities: WorkflowCapability[];
+} | {
+    status: 'pending';
+});

package/dist/types/native-material-snapshot.js

@@ -0,0 +1 @@
+export {};

package/dist/types/native-node-planning.d.ts

@@ -0,0 +1,253 @@
+import type { ApiBindingMaterial } from './api-bindings.js';
+import type { z } from 'zod';
+import type { JsonValueObject } from './api-arguments.js';
+import type { JsonObject } from './openapi.js';
+import type { BindingSchema } from './api-bindings.js';
+import type { NativeOutputContract } from './node-output.js';
+import type { NativeInstanceDependencyPlan, NativeNodeConfigurationDependencies } from './native-instance-dependencies.js';
+import type { WorkflowNativeMaterialSources, MissingWorkflowNativeMaterialRequirement, ResolveNativeMaterialSnapshotInput } from './native-material-snapshot.js';
+import type { WorkflowReviewGap } from './reviewable-workflow.js';
+import type { PlannedNativeNode, WorkflowCapability, WorkflowPlanGap, WorkflowPlanNodeContract, NativeRuntimeParameterSelection } from './workflow-plan.js';
+export interface NativeNodePlanningInput {
+    planId: string;
+    scenario: string;
+    capabilities?: WorkflowCapability[];
+    apiMaterials?: ApiBindingMaterial[];
+    preparedNativeNodes?: PlannedNativeNode[];
+    allowRuntimeParameters?: boolean;
+}
+export interface NativePlanningCapabilityMaterial {
+    name: string;
+    description: string;
+    parametersSchema: BindingSchema;
+    parameterReferenceSources?: WorkflowCapability['parameterReferenceSources'];
+    parameterSources: ('literal' | 'workflow-input' | 'workflow-fields')[];
+    materialRequirements?: WorkflowCapability['materialRequirements'];
+    materialSources?: WorkflowNativeMaterialSources;
+}
+export interface PreparedNativeNodeMaterial extends PlannedNativeNode {
+    inputPorts: string[];
+    outputPorts: string[];
+}
+export interface NativePlanningApiMaterial {
+    callId: string;
+    purpose?: string;
+    key: ApiBindingMaterial['operation']['key'];
+    method: string;
+    path: string;
+    operation: ApiBindingMaterial['operation']['operation'];
+    effective: ApiBindingMaterial['operation']['effective'];
+}
+export interface NativeNodePlanningContext {
+    scenario: string;
+    apiMaterials: NativePlanningApiMaterial[];
+    preparedNativeNodes: PreparedNativeNodeMaterial[];
+    capabilities: NativePlanningCapabilityMaterial[];
+}
+export interface NativeNodePlanningDescription {
+    input: NativeNodePlanningSnapshot;
+    context: NativeNodePlanningContext;
+    planningCapabilities: WorkflowCapability[];
+}
+export interface NativeNodePlanningSnapshot extends NativeNodePlanningInput {
+    capabilities: WorkflowCapability[];
+    apiMaterials: ApiBindingMaterial[];
+    preparedNativeNodes: PlannedNativeNode[];
+}
+export interface NativePlanningProposal {
+    nativeNodes: PlannedNativeNode[];
+    gaps: WorkflowPlanGap[];
+}
+export interface NativePlanningResult {
+    /** Only newly proposed instances, not supplied prepared instances. */
+    nativeNodes: PlannedNativeNode[];
+    gaps: WorkflowReviewGap[];
+}
+export interface CreateNativeNodePlanInput extends NativeNodePlanningInput {
+    proposal: NativePlanningProposal;
+}
+export interface NativePlanningNodeReason {
+    nodeId: string;
+    reason: string;
+}
+export type NativePlanningAssessment = {
+    kind: 'additions';
+    nodes: NativePlanningNodeReason[];
+} | {
+    kind: 'no-additions';
+    reason: string;
+};
+export interface NativePlanningVerification {
+    /** Derived after parameter validation; these are not invented model-visible schemas. */
+    contracts: WorkflowPlanNodeContract[];
+    outputs: NativeOutputContract[];
+}
+export interface NativePlanningRecordFields {
+    planId: string;
+    plan: NativePlanningResult;
+    evidence: {
+        kind: 'native-planning-context';
+        context: NativeNodePlanningContext;
+    };
+    verification: NativePlanningVerification;
+}
+export type NativeNodePlanningRecord = NativePlanningRecordFields & ({
+    kind: 'no-capabilities';
+} | {
+    kind: 'model-plan';
+    assessment: NativePlanningAssessment;
+});
+export interface CreateNativeNodePlanningRecordInput extends NativeNodePlanningInput {
+    plan: NativePlanningResult;
+    assessment?: NativePlanningAssessment;
+}
+export interface ValidateNativeNodePlanningRecordInput extends NativeNodePlanningInput {
+    plan: NativePlanningResult;
+    record: NativeNodePlanningRecord;
+}
+export type NativeInstanceOwnership = {
+    parameterSource: 'literal';
+} | {
+    parameterSource: 'workflow-input';
+} | {
+    parameterSource: 'workflow-fields';
+    pointers: string[];
+};
+export type NativeInstanceChoice = NativeInstanceOwnership & {
+    capability: string;
+    purpose: string;
+    reason?: string;
+};
+export interface NativeInstanceSelectionProposal {
+    instances: NativeInstanceChoice[];
+    gaps: WorkflowPlanGap[];
+    reason?: string;
+}
+export interface NativeInstanceSelectionInput extends NativeNodePlanningInput {
+    includeExplanations?: boolean;
+}
+export interface SelectedNativeInstance {
+    id: string;
+    capability: string;
+    purpose: string;
+    reason?: string;
+    literalParametersSchema: BindingSchema;
+    hasLiteralParameters: boolean;
+    runtimeParameters?: true | NativeRuntimeParameterSelection;
+}
+export interface NativeInstanceSelection {
+    id: string;
+    proposal: NativeInstanceSelectionProposal;
+    context: NativeInstanceSelectionContext;
+    includeExplanations: boolean;
+    instances: SelectedNativeInstance[];
+    gaps: WorkflowReviewGap[];
+}
+export interface NativeInstanceSelectionContext extends NativeNodePlanningContext {
+    parameterPlanning: {
+        stage: 'separate-value-generation';
+        missingPlanTimeValues: 'ask-in-value-stage';
+    };
+}
+export interface NativeInstanceSelectionDescription extends Omit<NativeNodePlanningDescription, 'context'> {
+    context: NativeInstanceSelectionContext;
+}
+export interface ResolveNativeInstanceSelectionInput extends NativeInstanceSelectionInput {
+    proposal: NativeInstanceSelectionProposal;
+}
+export interface NativeSelectedPlanningInput extends NativeInstanceSelectionInput {
+    selection: NativeInstanceSelection;
+}
+export interface NativeNodeConfigurationInput extends NativeSelectedPlanningInput {
+    nodeId: string;
+    /** Optional explicit producer choices, checked independently of runtime DAG edges. */
+    dependencies?: NativeInstanceDependencyPlan;
+    /** Explicit completed materials, never inferred from the selection order. */
+    configuredNodes?: PlannedNativeNode[];
+    /** Ordered answers to original questions from this exact instance/material revision. */
+    replies?: NativeNodeConfigurationReply[];
+}
+export interface NativeParameterGenerationInput {
+    nodeId: string;
+    capability: WorkflowCapability;
+    runtimeParameters?: true | NativeRuntimeParameterSelection;
+}
+export interface NativeParameterGenerationContract {
+    literalParametersSchema: BindingSchema;
+    valuesSchema: z.ZodType<JsonValueObject>;
+    definitions: JsonObject;
+    hasLiteralParameters: boolean;
+}
+export type NativeNodeParameterDecision = {
+    status: 'provided';
+    parameters: JsonValueObject;
+    reason?: string;
+} | {
+    status: 'needs-clarification';
+    message: string;
+    reason?: string;
+};
+export interface NativeNodeParameterProposal {
+    decision: NativeNodeParameterDecision;
+}
+export interface NativeNodeConfigurationDescription {
+    fingerprint: string;
+    context: NativeInstanceSelectionContext;
+    instance: SelectedNativeInstance;
+    configuredNodes: PreparedNativeNodeMaterial[];
+    outputs: NativeOutputContract[];
+    replies?: NativeNodeConfigurationReply[];
+    sourceDependencies?: NativeNodeConfigurationDependencies;
+}
+export interface NativeConfigurationMaterialContext {
+    selection: NativeInstanceSelection;
+    instance: SelectedNativeInstance;
+    snapshot: NativeNodePlanningSnapshot;
+    capabilities: WorkflowCapability[];
+    configuredNodes: PlannedNativeNode[];
+    outputs: NativeOutputContract[];
+    definition: WorkflowCapability;
+    sourceDependencies?: NativeNodeConfigurationDependencies;
+}
+export interface ResolvedNativeConfigurationMaterials extends NativeConfigurationMaterialContext {
+    capability: WorkflowCapability;
+    contract: NativeParameterGenerationContract;
+}
+export type ResolveNativePlanningMaterialsInput = Omit<ResolveNativeMaterialSnapshotInput, 'deferredNodeIds' | 'shouldDeferNode'>;
+export interface ResolvedNativePlanningMaterials {
+    capabilities: WorkflowCapability[];
+    outputs: NativeOutputContract[];
+}
+export type NativeNodeConfigurationReadiness = {
+    status: 'ready';
+    nodeId: string;
+} | {
+    status: 'awaiting-materials';
+    nodeId: string;
+    capability: string;
+    missingContext: MissingWorkflowNativeMaterialRequirement[];
+    pendingSourceNodeIds?: string[];
+};
+export interface ResolveNativeNodeParametersInput extends NativeNodeConfigurationInput {
+    fingerprint: string;
+    proposal: NativeNodeParameterProposal;
+}
+export interface ReadyNativeNodeParameters {
+    status: 'ready';
+    fingerprint: string;
+    node: PlannedNativeNode;
+    proposal: NativeNodeParameterProposal;
+}
+export interface NativeNodeParameterQuestion {
+    status: 'needs-clarification';
+    id: string;
+    fingerprint: string;
+    nodeId: string;
+    message: string;
+    proposal: NativeNodeParameterProposal;
+}
+export interface NativeNodeConfigurationReply {
+    question: NativeNodeParameterQuestion;
+    text: string;
+}
+export type NativeNodeParameterResult = ReadyNativeNodeParameters | NativeNodeParameterQuestion;

package/dist/types/native-node-planning.js

@@ -0,0 +1 @@
+export {};

package/dist/types/native-parameter-reference.d.ts

@@ -0,0 +1,17 @@
+import type { WorkflowValueReference, PlannedNativeNode, WorkflowCapability } from './workflow-plan.js';
+export interface WorkflowExclusiveOutputReference {
+    source: 'exclusive-output';
+    nodeId: string;
+}
+export type WorkflowNativeParameterReference = WorkflowValueReference | WorkflowExclusiveOutputReference;
+/** Implementation-owned locations; never discovered by matching property names or values. */
+export interface WorkflowNativeReferenceBinding {
+    nodeIdPointer: string;
+    /** Omitted means the implementation owns a fixed value pointer, not a model field. */
+    valuePointer?: string;
+    reference: WorkflowNativeParameterReference;
+}
+export interface DescribeNativeReferenceBindingsInput {
+    node: PlannedNativeNode;
+    capability: WorkflowCapability;
+}

package/dist/types/native-parameter-reference.js

@@ -0,0 +1 @@
+export {};

package/dist/types/native-producer-dependencies.d.ts

@@ -0,0 +1,9 @@
+export interface NativeProducerDependencyTarget {
+    nodeId: string;
+    description: string;
+    sourceNodeIds: string[];
+}
+export interface NativeProducerDependencySchemaInput {
+    targets: NativeProducerDependencyTarget[];
+    includeExplanations: boolean;
+}

package/dist/types/native-producer-dependencies.js

@@ -0,0 +1 @@
+export {};

package/dist/types/native-producer-eligibility.d.ts

@@ -0,0 +1,11 @@
+import type { WorkflowCapability } from './workflow-plan.js';
+import type { WorkflowNativeParameterReference } from './native-parameter-reference.js';
+export interface NativeParameterProducerCandidate {
+    nodeId: string;
+    referenceSources: WorkflowNativeParameterReference['source'][];
+}
+export interface SelectNativeParameterProducersInput {
+    nodeId: string;
+    capability: WorkflowCapability;
+    producers: NativeParameterProducerCandidate[];
+}

package/dist/types/native-producer-eligibility.js

@@ -0,0 +1 @@
+export {};

package/dist/types/native-reference-validation.d.ts

@@ -0,0 +1,12 @@
+import type { WorkflowNativeParameterReference } from './native-parameter-reference.js';
+import type { WorkflowDraftReferenceSources } from './workflow-draft-reference-sources.js';
+import type { PlannedNativeNode, WorkflowCapability } from './workflow-plan.js';
+export interface ValidateWorkflowDraftNativeReferenceInput {
+    reference: WorkflowNativeParameterReference;
+    sources: WorkflowDraftReferenceSources;
+}
+export interface ValidateWorkflowDraftNativeReferencesInput {
+    node: PlannedNativeNode;
+    capability: WorkflowCapability;
+    sources: WorkflowDraftReferenceSources;
+}

package/dist/types/native-reference-validation.js

@@ -0,0 +1 @@
+export {};

package/dist/types/native-runtime-inputs.d.ts

@@ -0,0 +1,53 @@
+import type { JsonValue } from './api-arguments.js';
+import type { BindingSchema, RequestContainerKind } from './api-bindings.js';
+import type { JsonValueObject } from './api-arguments.js';
+import type { PlannedNativeNode, WorkflowCapability } from './workflow-plan.js';
+import type { DeferredApiInputSlot } from './deferred-api-inputs.js';
+export interface NativeRuntimeInputSlot {
+    kind: 'native-parameters-input';
+    state: 'deferred';
+    id: string;
+    nodeId: string;
+    capability: string;
+    targetPointer: string;
+    schema: BindingSchema;
+    description: string;
+}
+export interface NativeRuntimeParameterInputSource {
+    id: string;
+    targetPointer: string;
+    containerKinds: Record<string, RequestContainerKind>;
+}
+export interface NativeRuntimeParameterMaterialization {
+    nodeId: string;
+    parameters: JsonValueObject;
+    schema: BindingSchema;
+    inputs: NativeRuntimeParameterInputSource[];
+}
+export type WorkflowRuntimeInputSlot = DeferredApiInputSlot | NativeRuntimeInputSlot;
+export type NativeRuntimeInputValues = Record<string, JsonValue>;
+export interface CollectNativeRuntimeInputSlotsInput {
+    nativeNodes: PlannedNativeNode[];
+    capabilities: WorkflowCapability[];
+}
+export interface InspectNativeRuntimeInputsInput extends CollectNativeRuntimeInputSlotsInput {
+    inputValues: NativeRuntimeInputValues;
+}
+export interface NativeRuntimeInputIssue {
+    code: 'missing-input' | 'unknown-input' | 'invalid-value';
+    inputId: string;
+    nodeId?: string;
+    message: string;
+}
+export interface ReadyNativeRuntimeInputs {
+    status: 'ready';
+    slots: NativeRuntimeInputSlot[];
+    nativeNodes: PlannedNativeNode[];
+    issues: NativeRuntimeInputIssue[];
+}
+export interface PendingNativeRuntimeInputs {
+    status: 'needs-input' | 'invalid-input';
+    slots: NativeRuntimeInputSlot[];
+    issues: NativeRuntimeInputIssue[];
+}
+export type NativeRuntimeInputInspection = ReadyNativeRuntimeInputs | PendingNativeRuntimeInputs;

package/dist/types/native-runtime-inputs.js

@@ -0,0 +1 @@
+export {};

package/dist/types/planning-evidence.d.ts

@@ -0,0 +1,56 @@
+import type { ApiOperationContract } from './api-operation.js';
+import type { ApiOperationKey } from './api-catalog.js';
+import type { WorkflowCapability } from './workflow-plan.js';
+import type { WorkflowSourceMessage } from './workflow-draft.js';
+import type { BindingSchema } from './api-bindings.js';
+import type { WorkflowDraftClarification, WorkflowDraftClarificationDescription } from './workflow-draft-clarification.js';
+export interface WorkflowMessageEvidence {
+    kind: 'message';
+    messageId: string;
+    quote: string;
+}
+export interface WorkflowOasEvidence {
+    kind: 'oas';
+    operation: ApiOperationKey;
+    /** RFC 6901 pointer into the supplied resolved Operation Object. */
+    pointer: string;
+}
+export interface WorkflowNativeEvidence {
+    kind: 'native';
+    capability: string;
+}
+export interface WorkflowEntryPointContract {
+    kind: string;
+    description: string;
+}
+export interface WorkflowEntryPointEvidence {
+    kind: 'entrypoint';
+    entrypoint: string;
+}
+export type WorkflowPlanningEvidence = WorkflowMessageEvidence | WorkflowOasEvidence | WorkflowNativeEvidence | WorkflowEntryPointEvidence;
+export interface WorkflowPlanningContext {
+    messages: WorkflowSourceMessage[];
+    planningMessageIds?: string[];
+    operations?: ApiOperationContract[];
+    capabilities?: WorkflowCapability[];
+    entrypoint?: WorkflowEntryPointContract;
+    clarification?: WorkflowDraftClarification;
+}
+export interface DescribedWorkflowCapability {
+    name: string;
+    description: string;
+    parametersSchema: BindingSchema;
+    supportsRuntimeParameters?: true;
+    materialRequirements?: WorkflowCapability['materialRequirements'];
+}
+export interface WorkflowPlanningContextDescription {
+    messages: WorkflowSourceMessage[];
+    operations: ApiOperationContract[];
+    capabilities: DescribedWorkflowCapability[];
+    entrypoint?: WorkflowEntryPointContract;
+    clarification?: WorkflowDraftClarificationDescription;
+}
+export interface ValidateWorkflowPlanningEvidenceInput {
+    context: WorkflowPlanningContext;
+    evidence: WorkflowPlanningEvidence[];
+}

package/dist/types/planning-evidence.js

@@ -0,0 +1 @@
+export {};

package/dist/types/requested-api-inputs.d.ts

@@ -0,0 +1,8 @@
+import type { ApiArgumentValues, JsonValue } from './api-arguments.js';
+/** Presence required by the workflow request, separately from OAS requiredness. */
+export interface RequestedApiInputPresenceInput {
+    source: string;
+    rootPointer: string;
+    value: ApiArgumentValues | JsonValue | undefined;
+    requestedInputs?: string[];
+}

package/dist/types/requested-api-inputs.js

@@ -0,0 +1 @@
+export {};

package/dist/types/reviewable-workflow.d.ts

@@ -1,6 +1,7 @@
 import type { ApiOperationContract } from './api-operation.js';
 import type { ApiOperationKey } from './api-catalog.js';
 import type { OutputBinding } from './api-arguments.js';
+import type { WorkflowConnectionPlanningRecord } from './workflow-connection-planning.js';
 import type { WorkflowApiMaterial, WorkflowCapability, WorkflowGraphPlan, PlannedNativeNode, WorkflowPlanEdge } from './workflow-plan.js';
 export interface WorkflowReviewGap {
     id: string;
@@ -17,6 +18,7 @@ export interface BlockedWorkflowApiMaterial {
     status: 'blocked';
     callId: string;
     operation: ApiOperationContract;
+    purpose?: string;
     requestMediaType?: string;
     bindings: OutputBinding[];
     gapIds: string[];
@@ -39,6 +41,8 @@ export interface ReviewableWorkflowGraphProposal {
 export interface ReviewableWorkflowGraphPlan extends WorkflowGraphPlan {
     gaps: WorkflowReviewGap[];
     blockedCalls: BlockedWorkflowCall[];
+    /** Optional original connection-only decision and supplied-material evidence. */
+    connectionPlanning?: WorkflowConnectionPlanningRecord;
 }
 export interface ReviewableWorkflowPlanningContext {
     materials: ReviewableWorkflowApiMaterial[];

package/dist/types/schema-resource.d.ts

@@ -9,4 +9,10 @@ export interface SchemaResourceContext {
     reference: (schema: BindingSchema) => BindingSchema;
     resolve: (schema: BindingSchema) => BindingSchema;
     bundle: (projection: BindingSchema) => BindingSchema;
+    /** Compile reachable static schemas into direct named components; preserve all assertions. */
+    bundleStaticProjections: (projections: Record<string, BindingSchema>) => StaticSchemaProjectionBundle;
+}
+export interface StaticSchemaProjectionBundle {
+    projections: Record<string, BindingSchema>;
+    definitions: Record<string, BindingSchema>;
 }