@openapi-flow/core 0.2.0 → 0.3.0

package/dist/schemas/project-native-literal-parameters.js

@@ -0,0 +1,200 @@
+import { createSchemaResourceContext } from '../bindings/resources/create-schema-resource-context.js';
+import { pointerTokens } from '../bindings/json-pointer.js';
+import { projectLiteralInputSchema } from './project-literal-input-schema.js';
+import { isObject } from '../utils/is-object.js';
+/** Expand only finite selected paths; unselected recursive contracts retain static refs. */
+export function projectNativeLiteralParameters(schema, pointers, source) {
+    const original = createSchemaResourceContext(schema);
+    const bundle = original.bundleStaticProjections({
+        parameters: original.root,
+    });
+    const projection = bundle.projections.parameters;
+    if (typeof projection === 'boolean')
+        return projectLiteralInputSchema(projection, pointers.map(pointerTokens), source);
+    const root = { ...projection, $defs: bundle.definitions };
+    const resources = createSchemaResourceContext(root);
+    function expand(current, paths, visited = new Set()) {
+        if (typeof current === 'boolean' ||
+            !paths.length ||
+            paths.some((path) => !path.length))
+            return current;
+        if (typeof current.$ref === 'string') {
+            const identity = JSON.stringify([current.$ref, paths]);
+            if (visited.has(identity))
+                throw new Error(`${source}: recursive alias cannot resolve a selected parameter path`);
+            const next = new Set([...visited, identity]);
+            const siblings = { ...current };
+            delete siblings.$ref;
+            delete siblings.$id;
+            delete siblings.$defs;
+            return {
+                allOf: [
+                    expand(resources.resolve(current), paths, next),
+                    expand(siblings, paths, next),
+                ],
+            };
+        }
+        const result = { ...current };
+        delete result.$id;
+        delete result.$defs;
+        if (isObject(current.properties))
+            result.properties = Object.fromEntries(Object.entries(current.properties).map(([name, child]) => {
+                if (typeof child !== 'boolean' && !isObject(child))
+                    throw new Error(`${source}: invalid property schema ${name}`);
+                return [
+                    name,
+                    expand(child, paths
+                        .filter(([token]) => token === name)
+                        .map((path) => path.slice(1)), visited),
+                ];
+            }));
+        if (isObject(current.patternProperties))
+            result.patternProperties = Object.fromEntries(Object.entries(current.patternProperties).map(([pattern, child]) => {
+                if (typeof child !== 'boolean' && !isObject(child))
+                    throw new Error(`${source}: invalid pattern schema ${pattern}`);
+                return [
+                    pattern,
+                    expand(child, paths
+                        .filter(([name]) => new RegExp(pattern).test(name))
+                        .map((path) => path.slice(1)), visited),
+                ];
+            }));
+        if (typeof current.additionalProperties === 'boolean' ||
+            isObject(current.additionalProperties))
+            result.additionalProperties = expand(current.additionalProperties, paths.map((path) => path.slice(1)), visited);
+        if (typeof current.items === 'boolean' || isObject(current.items))
+            result.items = expand(current.items, paths.map((path) => path.slice(1)), visited);
+        if (Array.isArray(current.prefixItems))
+            result.prefixItems = current.prefixItems.map((child, index) => {
+                if (typeof child !== 'boolean' && !isObject(child))
+                    throw new Error(`${source}: invalid tuple schema`);
+                return expand(child, paths
+                    .filter(([token]) => token === String(index))
+                    .map((path) => path.slice(1)), visited);
+            });
+        for (const keyword of ['allOf', 'anyOf', 'oneOf']) {
+            const children = current[keyword];
+            if (!Array.isArray(children))
+                continue;
+            result[keyword] = children.map((child) => {
+                if (typeof child !== 'boolean' && !isObject(child))
+                    throw new Error(`${source}: invalid composition schema`);
+                return expand(child, paths, visited);
+            });
+        }
+        return result;
+    }
+    const literal = projectLiteralInputSchema(expand(resources.root, pointers.map(pointerTokens)), pointers.map(pointerTokens), source);
+    // In a closed object, an unmatched false property is already forbidden by
+    // additionalProperties:false. Omit only that redundant declaration; patterns
+    // and open objects must keep the explicit prohibition. Entirely owned empty
+    // object containers have no literal decision and are materialized by code.
+    // Never visit const/enum/example data as schemas.
+    function omitRedundantForbiddenProperties(current, location) {
+        if (typeof current === 'boolean')
+            return current;
+        const result = { ...current };
+        for (const keyword of [
+            'properties',
+            'patternProperties',
+            '$defs',
+            'definitions',
+            'dependentSchemas',
+        ]) {
+            const entries = current[keyword];
+            if (!isObject(entries))
+                continue;
+            result[keyword] = Object.fromEntries(Object.entries(entries)
+                .filter(([name, child]) => !(keyword === 'properties' &&
+                child === false &&
+                current.additionalProperties === false &&
+                (!isObject(current.patternProperties) ||
+                    !Object.keys(current.patternProperties).some((pattern) => new RegExp(pattern).test(name)))))
+                .map(([name, child]) => {
+                if (typeof child !== 'boolean' && !isObject(child))
+                    throw new Error(`${source}: invalid ${keyword} schema`);
+                return [
+                    name,
+                    omitRedundantForbiddenProperties(child, keyword === 'properties' && location !== undefined
+                        ? [...location, name]
+                        : undefined),
+                ];
+            })
+                .filter(([name, child]) => {
+                if (keyword !== 'properties' ||
+                    location === undefined ||
+                    current.additionalProperties !== false ||
+                    (Array.isArray(current.required) &&
+                        current.required.includes(name)) ||
+                    (isObject(current.patternProperties) &&
+                        Object.keys(current.patternProperties).some((pattern) => new RegExp(pattern).test(name))) ||
+                    typeof child === 'boolean' ||
+                    child.type !== 'object' ||
+                    child.additionalProperties !== false ||
+                    !isObject(child.properties) ||
+                    Object.keys(child.properties).length ||
+                    (Array.isArray(child.required) && child.required.length) ||
+                    Object.keys(child).some((key) => ![
+                        'type',
+                        'properties',
+                        'required',
+                        'additionalProperties',
+                        'description',
+                        'title',
+                        '$schema',
+                        'minProperties',
+                        'maxProperties',
+                    ].includes(key)) ||
+                    (typeof child.minProperties === 'number' &&
+                        child.minProperties > 0) ||
+                    (typeof child.maxProperties === 'number' &&
+                        child.maxProperties < 0))
+                    return true;
+                const path = [...location, name];
+                // An entirely runtime-owned, unambiguous object container is created
+                // from its original schema by the materializer, not chosen by an LLM.
+                return !pointers
+                    .map(pointerTokens)
+                    .some((target) => target.length > path.length &&
+                    path.every((token, index) => target[index] === token));
+            }));
+        }
+        for (const keyword of ['allOf', 'anyOf', 'oneOf', 'prefixItems']) {
+            const children = current[keyword];
+            if (!Array.isArray(children))
+                continue;
+            result[keyword] = children.map((child, index) => {
+                if (typeof child !== 'boolean' && !isObject(child))
+                    throw new Error(`${source}: invalid ${keyword} schema`);
+                return omitRedundantForbiddenProperties(child, keyword === 'prefixItems' && location !== undefined
+                    ? [...location, String(index)]
+                    : location);
+            });
+        }
+        for (const keyword of [
+            'items',
+            'additionalProperties',
+            'not',
+            'if',
+            'then',
+            'else',
+            'contains',
+            'unevaluatedProperties',
+            'unevaluatedItems',
+        ]) {
+            const child = current[keyword];
+            if (typeof child === 'boolean' || isObject(child))
+                result[keyword] = omitRedundantForbiddenProperties(child, ['items', 'contains'].includes(keyword) ? undefined : location);
+        }
+        return result;
+    }
+    return {
+        ...literal,
+        schema: typeof literal.schema === 'boolean'
+            ? literal.schema
+            : omitRedundantForbiddenProperties({
+                ...literal.schema,
+                $defs: bundle.definitions,
+            }, []),
+    };
+}

package/dist/schemas/requested-api-inputs-schema.d.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+/** Scenario-required presence is metadata, not a change to OAS requiredness. */
+export declare const requestedApiInputsSchema: z.ZodArray<z.ZodString>;

package/dist/schemas/requested-api-inputs-schema.js

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+/** Scenario-required presence is metadata, not a change to OAS requiredness. */
+export const requestedApiInputsSchema = z
+    .array(z.string().regex(/^\/(?:[^~]|~[01])*$/u))
+    .refine((pointers) => new Set(pointers).size === pointers.length, {
+    message: 'requestedInputs requires distinct non-root JSON Pointers',
+});

package/dist/schemas/workflow-clarification-answer-revision-schema.d.ts

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+export declare const workflowClarificationAnswerChangeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"replace-answer">;
+    reply: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"single-choice">;
+        questionId: z.ZodString;
+        choiceId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"multiple-choice">;
+        questionId: z.ZodString;
+        choiceIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"text">;
+        questionId: z.ZodString;
+        text: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"defer">;
+        questionId: z.ZodString;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"reopen-question">;
+    questionId: z.ZodString;
+}, z.core.$strict>], "kind">;
+export declare const workflowClarificationAnswerChangesSchema: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"replace-answer">;
+    reply: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"single-choice">;
+        questionId: z.ZodString;
+        choiceId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"multiple-choice">;
+        questionId: z.ZodString;
+        choiceIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"text">;
+        questionId: z.ZodString;
+        text: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"defer">;
+        questionId: z.ZodString;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"reopen-question">;
+    questionId: z.ZodString;
+}, z.core.$strict>], "kind">>;

package/dist/schemas/workflow-clarification-answer-revision-schema.js

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+import { planningEvidenceTextSchema } from './planning-evidence-schema.js';
+import { workflowClarificationReplySchema } from './workflow-clarification-reply-schema.js';
+export const workflowClarificationAnswerChangeSchema = z.discriminatedUnion('kind', [
+    z.strictObject({
+        kind: z.literal('replace-answer'),
+        reply: workflowClarificationReplySchema,
+    }),
+    z.strictObject({
+        kind: z.literal('reopen-question'),
+        questionId: planningEvidenceTextSchema,
+    }),
+]);
+export const workflowClarificationAnswerChangesSchema = z
+    .array(workflowClarificationAnswerChangeSchema)
+    .min(1)
+    .superRefine((changes, context) => {
+    const ids = changes.map((change) => change.kind === 'replace-answer'
+        ? change.reply.questionId
+        : change.questionId);
+    if (new Set(ids).size !== ids.length)
+        context.addIssue({
+            code: 'custom',
+            message: 'Clarification answer changes repeat a question ID',
+        });
+});

package/dist/schemas/workflow-clarification-reply-schema.d.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+export declare const workflowClarificationReplySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"single-choice">;
+    questionId: z.ZodString;
+    choiceId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"multiple-choice">;
+    questionId: z.ZodString;
+    choiceIds: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"text">;
+    questionId: z.ZodString;
+    text: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"defer">;
+    questionId: z.ZodString;
+}, z.core.$strict>], "kind">;
+export declare const workflowClarificationRepliesSchema: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"single-choice">;
+    questionId: z.ZodString;
+    choiceId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"multiple-choice">;
+    questionId: z.ZodString;
+    choiceIds: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"text">;
+    questionId: z.ZodString;
+    text: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"defer">;
+    questionId: z.ZodString;
+}, z.core.$strict>], "kind">>;

package/dist/schemas/workflow-clarification-reply-schema.js

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+import { planningEvidenceTextSchema } from './planning-evidence-schema.js';
+export const workflowClarificationReplySchema = z.discriminatedUnion('kind', [
+    z.strictObject({
+        kind: z.literal('single-choice'),
+        questionId: planningEvidenceTextSchema,
+        choiceId: planningEvidenceTextSchema,
+    }),
+    z.strictObject({
+        kind: z.literal('multiple-choice'),
+        questionId: planningEvidenceTextSchema,
+        choiceIds: z.array(planningEvidenceTextSchema).min(1),
+    }),
+    z.strictObject({
+        kind: z.literal('text'),
+        questionId: planningEvidenceTextSchema,
+        text: planningEvidenceTextSchema,
+    }),
+    z.strictObject({
+        kind: z.literal('defer'),
+        questionId: planningEvidenceTextSchema,
+    }),
+]);
+export const workflowClarificationRepliesSchema = z
+    .array(workflowClarificationReplySchema)
+    .superRefine((replies, context) => {
+    if (new Set(replies.map((reply) => reply.questionId)).size !== replies.length)
+        context.addIssue({
+            code: 'custom',
+            message: 'Clarification replies repeat a question ID',
+        });
+    for (const [index, reply] of replies.entries())
+        if (reply.kind === 'multiple-choice' &&
+            new Set(reply.choiceIds).size !== reply.choiceIds.length)
+            context.addIssue({
+                code: 'custom',
+                path: [index, 'choiceIds'],
+                message: 'Selected choices must be distinct',
+            });
+});

package/dist/schemas/workflow-clarification-settings-schema.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+export declare const clarificationQuestionLimitsSchema: z.ZodObject<{
+    maxCategories: z.ZodNumber;
+    maxQuestionsPerCategory: z.ZodNumber;
+    maxChoicesPerQuestion: z.ZodNumber;
+    maxQuestionsPerRound: z.ZodNumber;
+}, z.core.$strict>;
+export declare const workflowClarificationOptionsSchema: z.ZodObject<{
+    includeExplanations: z.ZodOptional<z.ZodBoolean>;
+    includeSuggestions: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;

package/dist/schemas/workflow-clarification-settings-schema.js

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+const positiveInteger = z.number().int().min(1).max(Number.MAX_SAFE_INTEGER);
+export const clarificationQuestionLimitsSchema = z
+    .strictObject({
+    maxCategories: positiveInteger,
+    maxQuestionsPerCategory: positiveInteger,
+    maxChoicesPerQuestion: positiveInteger,
+    maxQuestionsPerRound: positiveInteger,
+})
+    .refine((limits) => limits.maxQuestionsPerRound / limits.maxQuestionsPerCategory <=
+    limits.maxCategories, {
+    message: 'maxQuestionsPerRound exceeds the configured category/question capacity',
+});
+export const workflowClarificationOptionsSchema = z.strictObject({
+    includeExplanations: z.boolean().optional(),
+    includeSuggestions: z.boolean().optional(),
+});

package/dist/schemas/workflow-connection-planning-schema.d.ts

@@ -0,0 +1,147 @@
+import { z } from 'zod';
+import type { WorkflowConnectionPlanningContext } from '../types/workflow-connection-planning.js';
+import type { WorkflowPlanningSourceEvidence } from '../types/workflow-planning-materials.js';
+import type { WorkflowPlanNodeContract } from '../types/workflow-plan.js';
+export declare const workflowConnectionIdentitySchema: z.ZodObject<{
+    scenario: z.ZodString;
+}, z.core.$strict>;
+export declare const workflowConnectionProposalSchema: z.ZodObject<{
+    edges: z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        output: z.ZodString;
+        to: z.ZodString;
+        input: z.ZodString;
+    }, z.core.$strict>>;
+    additionalGaps: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+    }, z.core.$strict>>;
+    blockedCalls: z.ZodArray<z.ZodObject<{
+        callId: z.ZodString;
+        gapIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const workflowConnectionDecisionSchema: z.ZodObject<{
+    reason: z.ZodString;
+    edges: z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        output: z.ZodString;
+        to: z.ZodString;
+        input: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$strict>>;
+    additionalGaps: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+    }, z.core.$strict>>;
+    blockedCalls: z.ZodArray<z.ZodObject<{
+        callId: z.ZodString;
+        gapIds: z.ZodArray<z.ZodString>;
+        reason: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const workflowConnectionPlanningResultSchema: z.ZodObject<{
+    nativeNodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        capability: z.ZodString;
+        parameters: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        runtimeParameters: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodObject<{
+            pointers: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>]>>;
+    }, z.core.$strict>>;
+    edges: z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        output: z.ZodString;
+        to: z.ZodString;
+        input: z.ZodString;
+    }, z.core.$strict>>;
+    gaps: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        stage: z.ZodEnum<{
+            "api-selection": "api-selection";
+            "api-bindings": "api-bindings";
+            "workflow-graph": "workflow-graph";
+        }>;
+        description: z.ZodString;
+        operation: z.ZodOptional<z.ZodObject<{
+            documentId: z.ZodString;
+            snapshotId: z.ZodString;
+            operationRef: z.ZodString;
+        }, z.core.$strict>>;
+        callId: z.ZodOptional<z.ZodString>;
+        targetPointer: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    blockedCalls: z.ZodArray<z.ZodObject<{
+        callId: z.ZodString;
+        gapIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    starts: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+/** Nested source receipts must match independently reconstructed source data. */
+export declare const workflowConnectionPlanningRecordSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"proposed-connections">;
+    decision: z.ZodObject<{
+        reason: z.ZodString;
+        edges: z.ZodArray<z.ZodObject<{
+            from: z.ZodString;
+            output: z.ZodString;
+            to: z.ZodString;
+            input: z.ZodString;
+            reason: z.ZodString;
+        }, z.core.$strict>>;
+        additionalGaps: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            description: z.ZodString;
+        }, z.core.$strict>>;
+        blockedCalls: z.ZodArray<z.ZodObject<{
+            callId: z.ZodString;
+            gapIds: z.ZodArray<z.ZodString>;
+            reason: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    plan: z.ZodObject<{
+        nativeNodes: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            capability: z.ZodString;
+            parameters: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            runtimeParameters: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodObject<{
+                pointers: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>]>>;
+        }, z.core.$strict>>;
+        edges: z.ZodArray<z.ZodObject<{
+            from: z.ZodString;
+            output: z.ZodString;
+            to: z.ZodString;
+            input: z.ZodString;
+        }, z.core.$strict>>;
+        gaps: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            stage: z.ZodEnum<{
+                "api-selection": "api-selection";
+                "api-bindings": "api-bindings";
+                "workflow-graph": "workflow-graph";
+            }>;
+            description: z.ZodString;
+            operation: z.ZodOptional<z.ZodObject<{
+                documentId: z.ZodString;
+                snapshotId: z.ZodString;
+                operationRef: z.ZodString;
+            }, z.core.$strict>>;
+            callId: z.ZodOptional<z.ZodString>;
+            targetPointer: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        blockedCalls: z.ZodArray<z.ZodObject<{
+            callId: z.ZodString;
+            gapIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        starts: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    evidence: z.ZodObject<{
+        kind: z.ZodLiteral<"supplied-connection-materials">;
+        context: z.ZodCustom<WorkflowConnectionPlanningContext, WorkflowConnectionPlanningContext>;
+        sources: z.ZodCustom<WorkflowPlanningSourceEvidence, WorkflowPlanningSourceEvidence>;
+    }, z.core.$strict>;
+    verification: z.ZodObject<{
+        contracts: z.ZodArray<z.ZodCustom<WorkflowPlanNodeContract, WorkflowPlanNodeContract>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;

package/dist/schemas/workflow-connection-planning-schema.js

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+import { planningEvidenceTextSchema } from './planning-evidence-schema.js';
+import { workflowDraftNativeNodeSchema, workflowDraftEdgeSchema, } from './workflow-draft-schema.js';
+import { workflowReviewGapSchema, workflowBlockedCallSchema, } from './workflow-planning-material-schema.js';
+export const workflowConnectionIdentitySchema = z.strictObject({
+    scenario: planningEvidenceTextSchema,
+});
+export const workflowConnectionProposalSchema = z.strictObject({
+    edges: z.array(workflowDraftEdgeSchema),
+    additionalGaps: z.array(z.strictObject({
+        id: planningEvidenceTextSchema,
+        description: planningEvidenceTextSchema,
+    })),
+    blockedCalls: z.array(workflowBlockedCallSchema),
+});
+export const workflowConnectionDecisionSchema = z.strictObject({
+    reason: planningEvidenceTextSchema,
+    edges: z.array(workflowDraftEdgeSchema.extend({ reason: planningEvidenceTextSchema })),
+    additionalGaps: workflowConnectionProposalSchema.shape.additionalGaps,
+    blockedCalls: z.array(workflowBlockedCallSchema.extend({
+        reason: planningEvidenceTextSchema,
+    })),
+});
+export const workflowConnectionPlanningResultSchema = z.strictObject({
+    nativeNodes: z.array(workflowDraftNativeNodeSchema),
+    edges: z.array(workflowDraftEdgeSchema),
+    gaps: z.array(workflowReviewGapSchema),
+    blockedCalls: z.array(workflowBlockedCallSchema),
+    starts: z.array(planningEvidenceTextSchema),
+});
+/** Nested source receipts must match independently reconstructed source data. */
+export const workflowConnectionPlanningRecordSchema = z.strictObject({
+    kind: z.literal('proposed-connections'),
+    decision: workflowConnectionDecisionSchema,
+    plan: workflowConnectionPlanningResultSchema,
+    evidence: z.strictObject({
+        kind: z.literal('supplied-connection-materials'),
+        context: z.custom(),
+        sources: z.custom(),
+    }),
+    verification: z.strictObject({
+        contracts: z.array(z.custom()),
+    }),
+});

package/dist/schemas/workflow-draft-api-binding-answer-schema.d.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+export declare const workflowDraftApiBindingAnswerSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"choose-source">;
+    questionId: z.ZodString;
+    choiceId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"bind-source">;
+    questionId: z.ZodString;
+    sourceNodeId: z.ZodString;
+    sourcePointer: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"no-binding">;
+    questionId: z.ZodString;
+}, z.core.$strict>], "kind">;
+export declare const workflowDraftApiBindingAnswersSchema: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"choose-source">;
+    questionId: z.ZodString;
+    choiceId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"bind-source">;
+    questionId: z.ZodString;
+    sourceNodeId: z.ZodString;
+    sourcePointer: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"no-binding">;
+    questionId: z.ZodString;
+}, z.core.$strict>], "kind">>;

package/dist/schemas/workflow-draft-api-binding-answer-schema.js

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import { planningEvidenceTextSchema } from './planning-evidence-schema.js';
+export const workflowDraftApiBindingAnswerSchema = z.discriminatedUnion('kind', [
+    z.strictObject({
+        kind: z.literal('choose-source'),
+        questionId: planningEvidenceTextSchema,
+        choiceId: planningEvidenceTextSchema,
+    }),
+    z.strictObject({
+        kind: z.literal('bind-source'),
+        questionId: planningEvidenceTextSchema,
+        sourceNodeId: planningEvidenceTextSchema,
+        sourcePointer: z.string(),
+    }),
+    z.strictObject({
+        kind: z.literal('no-binding'),
+        questionId: planningEvidenceTextSchema,
+    }),
+]);
+export const workflowDraftApiBindingAnswersSchema = z
+    .array(workflowDraftApiBindingAnswerSchema)
+    .min(1)
+    .refine((answers) => new Set(answers.map((answer) => answer.questionId)).size ===
+    answers.length, 'Binding answers must identify distinct current questions');

package/dist/schemas/workflow-draft-api-binding-edit-schema.d.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+import type { WorkflowDraftApiBindingEditDescription, WorkflowDraftApiBindingEditProposal } from '../types/workflow-draft-api-binding-edit.js';
+import type { WorkflowMessageEvidence } from '../types/planning-evidence.js';
+/** Only semantic ownership/source choices. Node kind, identities and patch values are code-owned. */
+export declare function createWorkflowDraftApiBindingEditProposalSchema(context: WorkflowDraftApiBindingEditDescription, messageSchema?: z.ZodType<WorkflowMessageEvidence>): z.ZodType<WorkflowDraftApiBindingEditProposal>;