@openapi-flow/core 0.3.11 → 0.3.12

package/dist/arguments/clarification/extraction/create-api-input-answer-extraction-record.js

@@ -5,6 +5,7 @@ export function createApiInputAnswerExtractionRecord(input) {
     const evidence = captureApiInputAnswerContext({
         reply: input.reply,
         requirements: input.requirements,
+        ...(input.purpose === undefined ? {} : { purpose: input.purpose }),
         ...(input.selectOasEnums === undefined
             ? {}
             : { selectOasEnums: input.selectOasEnums }),

package/dist/arguments/clarification/extraction/resolve-api-input-answer-interpretations.js

@@ -8,6 +8,7 @@ export function resolveApiInputAnswerInterpretations(input) {
     const context = captureApiInputAnswerContext({
         reply: input.reply,
         requirements: input.requirements,
+        ...(input.purpose === undefined ? {} : { purpose: input.purpose }),
         ...(input.selectOasEnums === undefined
             ? {}
             : { selectOasEnums: input.selectOasEnums }),

package/dist/arguments/clarification/extraction/resolve-api-input-answer-sources.js

@@ -8,6 +8,7 @@ export function resolveApiInputAnswerSources(input) {
     const context = captureApiInputAnswerContext({
         reply: input.reply,
         requirements: input.requirements,
+        ...(input.purpose === undefined ? {} : { purpose: input.purpose }),
     });
     const selections = apiInputAnswerSourcesSchema.parse(input.selections);
     const answered = new Set();

package/dist/arguments/clarification/extraction/resolve-api-input-source-selections.js

@@ -6,6 +6,7 @@ export function resolveApiInputSourceSelections(input) {
     const context = captureApiInputAnswerContext({
         reply: input.reply,
         requirements: input.requirements,
+        ...(input.purpose === undefined ? {} : { purpose: input.purpose }),
     });
     const catalog = describeApiInputSources(context.reply);
     const selections = apiInputAnswerSelectionsSchema.parse(input.selections);

package/dist/arguments/clarification/extraction/validate-api-input-answer-analysis.js

@@ -6,6 +6,7 @@ export function validateApiInputAnswerAnalysis(input) {
     const context = {
         reply: input.reply,
         requirements: input.requirements,
+        ...(input.purpose === undefined ? {} : { purpose: input.purpose }),
         ...(input.selectOasEnums === undefined
             ? {}
             : { selectOasEnums: input.selectOasEnums }),

package/dist/arguments/clarification/extraction/validate-api-input-answer-extraction-record.js

@@ -5,6 +5,7 @@ export function validateApiInputAnswerExtractionRecord(input) {
     const expected = createApiInputAnswerExtractionRecord({
         reply: input.reply,
         requirements: input.requirements,
+        ...(input.purpose === undefined ? {} : { purpose: input.purpose }),
         ...(input.selectOasEnums === undefined
             ? {}
             : { selectOasEnums: input.selectOasEnums }),

package/dist/arguments/enum/describe-api-argument-enum-context.d.ts

@@ -0,0 +1,4 @@
+import type { ApiArgumentEnumContextInput } from '../../types/api-argument-enum.js';
+import type { ApiInputAnswerContext } from '../../types/api-input-answer-extraction.js';
+/** Derive real unanswered OAS enum questions, not a synthetic draft/edit plan. */
+export declare function describeApiArgumentEnumContext(input: ApiArgumentEnumContextInput): ApiInputAnswerContext;

package/dist/arguments/enum/describe-api-argument-enum-context.js

@@ -0,0 +1,41 @@
+import { describeApiLiteralGeneration } from '../generation/describe-api-literal-generation.js';
+import { inspectApiArgumentRequirements } from '../clarification/inspect-api-argument-requirements.js';
+import { describeApiInputEnumAnswerChoices } from './describe-api-input-enum-answer-choices.js';
+import { applyConfirmedApiInputs } from '../clarification/apply-confirmed-api-inputs.js';
+import { resolveApiLiteralProposalSources } from '../sources/resolve-api-literal-proposal-sources.js';
+import { expandRequestedEnumRequirements } from './expand-requested-enum-requirements.js';
+/** Derive real unanswered OAS enum questions, not a synthetic draft/edit plan. */
+export function describeApiArgumentEnumContext(input) {
+    const { input: snapshot, contract } = describeApiLiteralGeneration(input);
+    const proposal = contract.schema.parse(input.proposal);
+    resolveApiLiteralProposalSources({
+        callId: snapshot.callId,
+        values: proposal.values,
+        sources: input.literalSources,
+        messages: [{ id: 'scenario', text: snapshot.scenario }],
+    });
+    const values = applyConfirmedApiInputs({
+        ...snapshot,
+        values: proposal.values,
+    });
+    const inspected = inspectApiArgumentRequirements({
+        ...snapshot,
+        values,
+        requestedInputs: input.requestedInputs,
+    });
+    const context = {
+        reply: snapshot.scenario,
+        requirements: expandRequestedEnumRequirements({
+            ...input,
+            values,
+            requirements: inspected.requirements,
+        }),
+        selectOasEnums: true,
+        ...(snapshot.purpose === undefined ? {} : { purpose: snapshot.purpose }),
+    };
+    const ids = new Set(describeApiInputEnumAnswerChoices(context).map((choice) => choice.requirementId));
+    return {
+        ...context,
+        requirements: context.requirements.filter((item) => ids.has(item.id)),
+    };
+}

package/dist/arguments/enum/expand-requested-enum-requirements.d.ts

@@ -0,0 +1,4 @@
+import type { ApiArgumentEnumRequirementsInput } from '../../types/api-argument-enum.js';
+import type { ApiInputRequirement } from '../../types/api-clarification.js';
+/** Missing containers need no fabricated value to expose their explicitly requested OAS descendants. */
+export declare function expandRequestedEnumRequirements(input: ApiArgumentEnumRequirementsInput): ApiInputRequirement[];

package/dist/arguments/enum/expand-requested-enum-requirements.js

@@ -0,0 +1,45 @@
+import { createHash } from 'node:crypto';
+import { requestBindingSchemas } from '../../bindings/request-binding-schema.js';
+import { unionBindingSchemas } from '../../bindings/combine-binding-schemas.js';
+import { hasPointer } from '../../bindings/json-pointer.js';
+/** Missing containers need no fabricated value to expose their explicitly requested OAS descendants. */
+export function expandRequestedEnumRequirements(input) {
+    const requirements = structuredClone(input.requirements);
+    const owned = [
+        ...input.bindings.map((binding) => binding.targetPointer),
+        ...(input.confirmedInputs === undefined
+            ? []
+            : input.confirmedInputs.map((value) => value.targetPointer)),
+    ];
+    for (const parent of input.requirements) {
+        if (parent.requestedInputs === undefined)
+            continue;
+        for (const targetPointer of parent.requestedInputs) {
+            if (requirements.some((item) => item.targetPointer === targetPointer) ||
+                hasPointer(input.values, targetPointer) ||
+                owned.some((pointer) => overlaps(pointer, targetPointer)))
+                continue;
+            const schemas = requestBindingSchemas(input, targetPointer);
+            if (!schemas.length)
+                throw new Error(`Requested enum input ${targetPointer} has no original OAS contract`);
+            const schema = unionBindingSchemas(schemas);
+            requirements.push({
+                ...parent,
+                kind: 'requested-input',
+                id: createHash('sha256')
+                    .update(JSON.stringify([parent.id, targetPointer, schema]))
+                    .digest('hex'),
+                targetPointer,
+                schema,
+                requestedInputs: [targetPointer],
+                message: `Provide scenario-requested value ${targetPointer} for ${input.operation.method} ${input.operation.path}.`,
+            });
+        }
+    }
+    return requirements;
+}
+function overlaps(left, right) {
+    return (left === right ||
+        left.startsWith(right + '/') ||
+        right.startsWith(left + '/'));
+}

package/dist/arguments/enum/resolve-api-argument-enum-interpretation.d.ts

@@ -0,0 +1,3 @@
+import type { ResolveApiArgumentEnumInterpretationInput, ApiArgumentEnumResolution } from '../../types/api-argument-enum.js';
+/** Replay copied OAS values against independently supplied input; keep semantic evidence separate. */
+export declare function resolveApiArgumentEnumInterpretation(input: ResolveApiArgumentEnumInterpretationInput): ApiArgumentEnumResolution;

package/dist/arguments/enum/resolve-api-argument-enum-interpretation.js

@@ -0,0 +1,26 @@
+import { describeApiArgumentEnumContext } from './describe-api-argument-enum-context.js';
+import { validateApiInputAnswerAnalysis } from '../clarification/extraction/validate-api-input-answer-analysis.js';
+import { assignApiInputValue } from '../clarification/assign-api-input-value.js';
+import { inspectApiArgumentRequirements } from '../clarification/inspect-api-argument-requirements.js';
+import { applyConfirmedApiInputs } from '../clarification/apply-confirmed-api-inputs.js';
+/** Replay copied OAS values against independently supplied input; keep semantic evidence separate. */
+export function resolveApiArgumentEnumInterpretation(input) {
+    const context = describeApiArgumentEnumContext(input);
+    validateApiInputAnswerAnalysis({ ...context, analysis: input.analysis });
+    const values = applyConfirmedApiInputs({
+        ...input,
+        values: input.proposal.values,
+    });
+    for (const answer of input.analysis.answers) {
+        const requirement = context.requirements.find((item) => item.id === answer.requirementId);
+        if (!requirement)
+            throw new Error(`API enum answer ${answer.requirementId} has no current OAS requirement`);
+        assignApiInputValue(values, requirement.targetPointer, structuredClone(answer.value), input);
+    }
+    const inspected = inspectApiArgumentRequirements({ ...input, values });
+    return {
+        values,
+        unresolvedInputs: inspected.requirements.map((item) => item.targetPointer),
+        interpretation: structuredClone({ ...context, analysis: input.analysis }),
+    };
+}

package/dist/arguments/sources/resolve-api-literal-proposal-sources.d.ts

@@ -0,0 +1,3 @@
+import type { ResolveApiLiteralProposalSourcesInput, VerifiedApiLiteralProposalSource } from '../../types/api-input-literal-source.js';
+/** The same source/coverage checks serve independent generation and draft editing. */
+export declare function resolveApiLiteralProposalSources(input: ResolveApiLiteralProposalSourcesInput): VerifiedApiLiteralProposalSource[];

package/dist/arguments/sources/resolve-api-literal-proposal-sources.js

@@ -0,0 +1,58 @@
+import { pointerTokens, pointerValue } from '../../bindings/json-pointer.js';
+import { verifyApiInputLiteralSource } from './verify-api-input-literal-source.js';
+/** The same source/coverage checks serve independent generation and draft editing. */
+export function resolveApiLiteralProposalSources(input) {
+    if (!input.callId?.trim() ||
+        !Array.isArray(input.sources) ||
+        !Array.isArray(input.messages))
+        throw new Error('Literal sources require callId, sources and original messages');
+    const sources = [];
+    for (const selection of input.sources) {
+        pointerTokens(selection.targetPointer);
+        const label = `API ${input.callId} literal ${selection.targetPointer}`;
+        if (sources.some((source) => overlaps(source.targetPointer, selection.targetPointer)))
+            throw new Error(`${label} has duplicate or overlapping literalSources`);
+        const message = input.messages.find((entry) => entry.id === selection.messageId);
+        if (!message)
+            throw new Error(`${label} cites unavailable user message ${selection.messageId}`);
+        const proposed = pointerValue(input.values, selection.targetPointer);
+        if (proposed === undefined)
+            throw new Error(`${label} source targets an absent proposed value`);
+        const parsed = verifyApiInputLiteralSource({
+            ...selection,
+            text: message.text,
+            label,
+            value: proposed,
+        });
+        sources.push({ ...selection, occurrences: parsed.occurrences });
+    }
+    function check(value, pointer) {
+        if (sources.some((source) => isAncestor(source.targetPointer, pointer)))
+            return;
+        if (value !== null &&
+            typeof value === 'object' &&
+            Object.keys(value).length) {
+            for (const [key, child] of Object.entries(value))
+                check(child, `${pointer}/${key.replaceAll('~', '~0').replaceAll('/', '~1')}`);
+            return;
+        }
+        throw new Error(`API ${input.callId} literal ${pointer} requires an exact user source in literalSources`);
+    }
+    for (const [root, value] of Object.entries(input.values)) {
+        if (root !== 'body' &&
+            value !== null &&
+            typeof value === 'object' &&
+            !Object.keys(value).length)
+            continue;
+        check(value, `/${root}`);
+    }
+    return sources;
+}
+function isAncestor(ancestor, pointer) {
+    return (ancestor === '' ||
+        pointer === ancestor ||
+        pointer.startsWith(`${ancestor}/`));
+}
+function overlaps(left, right) {
+    return isAncestor(left, right) || isAncestor(right, left);
+}

package/dist/draft/edits/api/resolve-workflow-draft-api-literal-sources.js

@@ -1,60 +1,13 @@
-import { pointerTokens, pointerValue } from '../../../bindings/json-pointer.js';
-import { verifyApiInputLiteralSource } from '../../../arguments/sources/verify-api-input-literal-source.js';
+import { resolveApiLiteralProposalSources } from '../../../arguments/sources/resolve-api-literal-proposal-sources.js';
 /** OAS validation and message existence alone do not establish a literal's origin. */
 export function resolveWorkflowDraftApiLiteralSources(input) {
     const { description, proposal } = input;
-    const sources = [];
-    const messages = [...description.messages, ...description.backgroundMessages];
-    if (proposal.literalSources !== undefined) {
-        for (const selection of proposal.literalSources) {
-            pointerTokens(selection.targetPointer);
-            const label = `API ${description.nodeId} literal ${selection.targetPointer}`;
-            if (sources.some((source) => overlaps(source.targetPointer, selection.targetPointer)))
-                throw new Error(`${label} has duplicate or overlapping literalSources`);
-            const message = messages.find((entry) => entry.id === selection.messageId);
-            if (!message)
-                throw new Error(`${label} cites unavailable user message ${selection.messageId}`);
-            const proposed = pointerValue(proposal.values, selection.targetPointer);
-            if (proposed === undefined)
-                throw new Error(`${label} source targets an absent proposed value`);
-            const parsed = verifyApiInputLiteralSource({
-                ...selection,
-                text: message.text,
-                label,
-                value: proposed,
-            });
-            sources.push({ ...selection, occurrences: parsed.occurrences });
-        }
-    }
-    function check(value, pointer) {
-        if (sources.some((source) => isAncestor(source.targetPointer, pointer)))
-            return;
-        if (value !== null &&
-            typeof value === 'object' &&
-            Object.keys(value).length) {
-            for (const [key, child] of Object.entries(value))
-                check(child, `${pointer}/${key.replaceAll('~', '~0').replaceAll('/', '~1')}`);
-            return;
-        }
-        throw new Error(`API ${description.nodeId} literal ${pointer} requires an exact user source in literalSources`);
-    }
-    for (const [root, value] of Object.entries(proposal.values)) {
-        // Empty parameter-location objects contain no request values. Empty body
-        // objects/arrays are actual data and still require their own source.
-        if (root !== 'body' &&
-            value !== null &&
-            typeof value === 'object' &&
-            !Object.keys(value).length)
-            continue;
-        check(value, `/${root}`);
-    }
-    return sources;
-}
-function isAncestor(ancestor, pointer) {
-    return (ancestor === '' ||
-        pointer === ancestor ||
-        pointer.startsWith(`${ancestor}/`));
-}
-function overlaps(left, right) {
-    return isAncestor(left, right) || isAncestor(right, left);
+    // Empty parameter-location objects contain no request values. Empty body
+    // objects/arrays are actual data and still require their own source.
+    return resolveApiLiteralProposalSources({
+        callId: description.nodeId,
+        values: proposal.values,
+        sources: proposal.literalSources === undefined ? [] : proposal.literalSources,
+        messages: [...description.messages, ...description.backgroundMessages],
+    });
 }

package/dist/public-api.d.ts

@@ -14,6 +14,13 @@ export type * from './types/api-operation.js';
 export { createApiArgumentsSchema } from './schemas/create-api-arguments-schema.js';
 export { createApiArgumentGenerationContract } from './schemas/create-api-argument-generation-contract.js';
 export type * from './types/api-argument-generation.js';
+export type * from './types/api-argument-enum.js';
+export type * from './types/api-input-literal-source.js';
+export { apiInputLiteralSourceSchema } from './schemas/api-input-literal-source-schema.js';
+export { resolveApiLiteralProposalSources } from './arguments/sources/resolve-api-literal-proposal-sources.js';
+export { createApiRequestInputPointerSchema } from './schemas/create-api-request-input-pointer-schema.js';
+export { describeApiArgumentEnumContext } from './arguments/enum/describe-api-argument-enum-context.js';
+export { resolveApiArgumentEnumInterpretation } from './arguments/enum/resolve-api-argument-enum-interpretation.js';
 export type * from './types/api-literal-generation.js';
 export { describeApiLiteralGeneration } from './arguments/generation/describe-api-literal-generation.js';
 export { createApiLiteralGenerationRecord } from './arguments/generation/create-api-literal-generation-record.js';

package/dist/public-api.js

@@ -10,6 +10,11 @@ export { createApiSelectionExplanation } from './openapi/selection/evidence/crea
 export { validateApiSelectionExplanation } from './openapi/selection/evidence/validate-api-selection-explanation.js';
 export { createApiArgumentsSchema } from './schemas/create-api-arguments-schema.js';
 export { createApiArgumentGenerationContract } from './schemas/create-api-argument-generation-contract.js';
+export { apiInputLiteralSourceSchema } from './schemas/api-input-literal-source-schema.js';
+export { resolveApiLiteralProposalSources } from './arguments/sources/resolve-api-literal-proposal-sources.js';
+export { createApiRequestInputPointerSchema } from './schemas/create-api-request-input-pointer-schema.js';
+export { describeApiArgumentEnumContext } from './arguments/enum/describe-api-argument-enum-context.js';
+export { resolveApiArgumentEnumInterpretation } from './arguments/enum/resolve-api-argument-enum-interpretation.js';
 export { describeApiLiteralGeneration } from './arguments/generation/describe-api-literal-generation.js';
 export { createApiLiteralGenerationRecord } from './arguments/generation/create-api-literal-generation-record.js';
 export { validateApiLiteralGenerationRecord } from './arguments/generation/validate-api-literal-generation-record.js';

package/dist/schemas/api-input-answer-extraction-schema.d.ts

@@ -43,6 +43,7 @@ export declare const apiInputAnswerContextSchema: z.ZodObject<{
         parameterDescription: z.ZodOptional<z.ZodString>;
         message: z.ZodString;
     }, z.core.$strict>>;
+    purpose: z.ZodOptional<z.ZodString>;
     selectOasEnums: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strict>;
 export declare const apiInputAnswerSourceSchema: z.ZodObject<{

package/dist/schemas/api-input-answer-extraction-schema.js

@@ -20,6 +20,11 @@ export const apiInputRequirementSchema = z.strictObject({
 export const apiInputAnswerContextSchema = z.strictObject({
     reply: z.string(),
     requirements: z.array(apiInputRequirementSchema),
+    purpose: z
+        .string()
+        .min(1)
+        .refine((value) => value.trim().length > 0)
+        .optional(),
     selectOasEnums: z.boolean().optional(),
 });
 export const apiInputAnswerSourceSchema = apiInputLiteralSourceSchema.extend({

package/dist/types/api-argument-enum.d.ts

@@ -0,0 +1,23 @@
+import type { ApiLiteralGenerationInput } from './api-literal-generation.js';
+import type { ApiArgumentValues, ApiArgumentProposal } from './api-arguments.js';
+import type { ApiInputAnswerAnalysis, ValidateApiInputAnswerAnalysisInput } from './api-input-answer-extraction.js';
+import type { ApiLiteralProposalSource } from './api-input-literal-source.js';
+import type { ApiInputRequirement } from './api-clarification.js';
+export interface ApiArgumentEnumRequirementsInput extends ApiArgumentEnumContextInput {
+    requirements: ApiInputRequirement[];
+    values: ApiArgumentValues;
+}
+export interface ApiArgumentEnumContextInput extends ApiLiteralGenerationInput {
+    /** Original literal proposal, before confirmed inputs or semantic OAS values are merged. */
+    proposal: ApiArgumentProposal;
+    literalSources: ApiLiteralProposalSource[];
+    requestedInputs?: string[];
+}
+export interface ResolveApiArgumentEnumInterpretationInput extends ApiArgumentEnumContextInput {
+    analysis: ApiInputAnswerAnalysis;
+}
+export interface ApiArgumentEnumResolution {
+    values: ApiArgumentValues;
+    unresolvedInputs: string[];
+    interpretation: ValidateApiInputAnswerAnalysisInput;
+}

package/dist/types/api-argument-enum.js

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

package/dist/types/api-arguments.d.ts

@@ -1,5 +1,7 @@
 import type { ApiOperationContract } from './api-operation.js';
 import type { ApiLiteralGenerationRecord } from './api-literal-generation.js';
+import type { ValidateApiInputAnswerAnalysisInput } from './api-input-answer-extraction.js';
+import type { VerifiedApiLiteralProposalSource } from './api-input-literal-source.js';
 export type JsonValue = string | number | boolean | null | JsonValue[] | JsonValueObject;
 export interface JsonValueObject {
     [key: string]: JsonValue;
@@ -35,6 +37,10 @@ export interface ApiCallArguments extends ApiArgumentProposal {
     requestMediaType?: string;
     /** Optional immutable attribution of the original literal proposal, not final merged values. */
     literalGeneration?: ApiLiteralGenerationRecord;
+    /** Opt-in interpretation of unresolved OAS enum inputs; never verbatim literal attribution. */
+    enumInterpretation?: ValidateApiInputAnswerAnalysisInput;
+    /** Code-verified coverage of the original literal proposal, excluding copied OAS values. */
+    literalSources?: VerifiedApiLiteralProposalSource[];
 }
 export interface ValidateApiArgumentsInput extends ApiArgumentsSchemaInput {
     values: ApiArgumentValues;

package/dist/types/api-input-answer-extraction.d.ts

@@ -3,6 +3,8 @@ import type { ApiInputEnumAnswerSelection, ResolvedApiInputAnswerInterpretations
 export interface ApiInputAnswerContext {
     reply: string;
     requirements: ApiInputRequirement[];
+    /** Caller-supplied call role, separate from the quoted answer/value source. */
+    purpose?: string;
     /** Allow semantic selection of original OAS enum values, never arbitrary generation. */
     selectOasEnums?: boolean;
 }

package/dist/types/api-input-literal-source.d.ts

@@ -1,5 +1,20 @@
 import type { JsonValue } from './api-arguments.js';
 import type { ApiInputAnswerSourceLocation } from './api-input-answer-extraction.js';
+import type { ApiArgumentValues } from './api-arguments.js';
+import type { WorkflowSourceMessage } from './workflow-draft.js';
+export interface ApiLiteralProposalSource extends ApiInputLiteralSource {
+    targetPointer: string;
+    messageId: string;
+}
+export interface VerifiedApiLiteralProposalSource extends ApiLiteralProposalSource {
+    occurrences: ApiInputAnswerSourceLocation[];
+}
+export interface ResolveApiLiteralProposalSourcesInput {
+    callId: string;
+    values: ApiArgumentValues;
+    sources: ApiLiteralProposalSource[];
+    messages: WorkflowSourceMessage[];
+}
 export interface ApiInputLiteralSource {
     sourceFormat: 'text' | 'json';
     sourceText: string;

package/dist/types/workflow-draft-api-literal-sources.d.ts

@@ -1,13 +1,7 @@
-import type { ApiInputLiteralSource } from './api-input-literal-source.js';
-import type { ApiInputAnswerSourceLocation } from './api-input-answer-extraction.js';
+import type { ApiLiteralProposalSource, VerifiedApiLiteralProposalSource } from './api-input-literal-source.js';
 import type { WorkflowDraftApiCallPlanningDescription, WorkflowDraftApiCallArgumentsProposal } from './workflow-draft-api-call-planning.js';
-export interface WorkflowDraftApiLiteralSource extends ApiInputLiteralSource {
-    targetPointer: string;
-    messageId: string;
-}
-export interface VerifiedWorkflowDraftApiLiteralSource extends WorkflowDraftApiLiteralSource {
-    occurrences: ApiInputAnswerSourceLocation[];
-}
+export type WorkflowDraftApiLiteralSource = ApiLiteralProposalSource;
+export type VerifiedWorkflowDraftApiLiteralSource = VerifiedApiLiteralProposalSource;
 export interface ResolveWorkflowDraftApiLiteralSourcesInput {
     description: WorkflowDraftApiCallPlanningDescription;
     proposal: WorkflowDraftApiCallArgumentsProposal;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openapi-flow/core",
-  "version": "0.3.11",
+  "version": "0.3.12",
   "license": "MIT",
   "description": "Engine-independent OpenAPI catalogs, operation contracts and typed request schemas",
   "keywords": [