@executioncontrolprotocol/core 0.10.0

package/dist/encoding/normalize-workflow.js

@@ -0,0 +1,109 @@
+function sortKeys(obj) {
+    const sorted = Object.keys(obj)
+        .sort()
+        .reduce((acc, key) => {
+        acc[key] = obj[key];
+        return acc;
+    }, {});
+    return sorted;
+}
+function normalizeInputValue(value) {
+    if (value === null || typeof value !== "object")
+        return value;
+    if (Array.isArray(value))
+        return value.map(normalizeInputValue);
+    if ("$ref" in value && typeof value.$ref === "string") {
+        return { $ref: value.$ref };
+    }
+    if ("$state" in value && typeof value.$state === "string") {
+        return { $state: value.$state };
+    }
+    const obj = value;
+    const out = {};
+    for (const key of Object.keys(obj).sort()) {
+        out[key] = normalizeInputValue(obj[key]);
+    }
+    return out;
+}
+function normalizeExpr(expr) {
+    if (expr === null || typeof expr !== "object")
+        return expr;
+    const obj = expr;
+    if ("eq" in obj && Array.isArray(obj.eq)) {
+        return { eq: [obj.eq[0], obj.eq[1]] };
+    }
+    if ("neq" in obj && Array.isArray(obj.neq)) {
+        return { neq: [obj.neq[0], obj.neq[1]] };
+    }
+    return sortKeys(obj);
+}
+function normalizeStepNode(node) {
+    const out = {
+        type: "step",
+        id: node.id,
+        uses: node.uses,
+    };
+    if (node.label)
+        out.label = node.label;
+    if (node.input)
+        out.input = normalizeInputValue(node.input);
+    if (node.as)
+        out.as = node.as;
+    if (node.mode)
+        out.mode = node.mode;
+    if (node.when)
+        out.when = normalizeExpr(node.when);
+    return out;
+}
+function normalizeNode(node) {
+    if (!node.type || node.type === "step") {
+        return normalizeStepNode(node);
+    }
+    if (node.type === "loop") {
+        const loop = node;
+        return {
+            type: "loop",
+            id: loop.id,
+            ...(loop.label ? { label: loop.label } : {}),
+            ...(loop.until ? { until: normalizeExpr(loop.until) } : {}),
+            ...(loop.maxRounds !== undefined ? { maxRounds: loop.maxRounds } : {}),
+            steps: loop.steps.map(normalizeNode),
+        };
+    }
+    if (node.type === "parallel") {
+        const par = node;
+        return {
+            type: "parallel",
+            id: par.id,
+            ...(par.label ? { label: par.label } : {}),
+            branches: par.branches.map((b) => b.map(normalizeNode)),
+        };
+    }
+    const branch = node;
+    return {
+        type: "branch",
+        id: branch.id,
+        ...(branch.label ? { label: branch.label } : {}),
+        branches: branch.branches.map((b) => ({
+            ...(b.label ? { label: b.label } : {}),
+            when: normalizeExpr(b.when),
+            steps: b.steps.map(normalizeNode),
+        })),
+    };
+}
+/**
+ * Normalize a workflow manifest for stable round-trip comparison.
+ * @category Encoding
+ */
+export function normalizeWorkflowManifest(manifest) {
+    return {
+        schema: "@executioncontrolprotocol.workflow",
+        version: manifest.version,
+        workflow: {
+            id: manifest.workflow.id,
+            ...(manifest.workflow.label ? { label: manifest.workflow.label } : {}),
+        },
+        steps: manifest.steps.map(normalizeNode),
+    };
+}
+//# sourceMappingURL=normalize-workflow.js.map

package/dist/encoding/normalize-workflow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize-workflow.js","sourceRoot":"","sources":["../../src/encoding/normalize-workflow.ts"],"names":[],"mappings":"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"}

package/dist/encoding/resolve.d.ts

@@ -0,0 +1,13 @@
+import type { CapabilityDefinition } from "../definitions/types.js";
+import type { Registry } from "../registry/registry.js";
+/**
+ * Resolve encode capability for an extension.
+ * @category Encoding
+ */
+export declare function resolveEncoder(registry: Registry, extensionId: string): CapabilityDefinition;
+/**
+ * Resolve decode capability for an extension.
+ * @category Encoding
+ */
+export declare function resolveDecoder(registry: Registry, extensionId: string): CapabilityDefinition;
+//# sourceMappingURL=resolve.d.ts.map

package/dist/encoding/resolve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../../src/encoding/resolve.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAA;AACnE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AAQvD;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,QAAQ,EAClB,WAAW,EAAE,MAAM,GAClB,oBAAoB,CAoBtB;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,QAAQ,EAClB,WAAW,EAAE,MAAM,GAClB,oBAAoB,CAoBtB"}

package/dist/encoding/resolve.js

@@ -0,0 +1,48 @@
+import { ECP_ENCODING_ERROR_CODES } from "@executioncontrolprotocol/types";
+import { normalizeNamespacedId, validateDecodeCapabilityContract, validateEncodeCapabilityContract, } from "./contracts.js";
+import { EcpError } from "./errors.js";
+/**
+ * Resolve encode capability for an extension.
+ * @category Encoding
+ */
+export function resolveEncoder(registry, extensionId) {
+    const normalized = normalizeNamespacedId(extensionId);
+    const capabilityId = `${normalized}.encode`;
+    const extensionDef = registry.getExtension(normalized);
+    if (!extensionDef) {
+        throw new EcpError(ECP_ENCODING_ERROR_CODES.FORMAT_EXTENSION_NOT_FOUND, {
+            message: `Extension ${normalized} is not registered.`,
+        });
+    }
+    const capabilityDef = registry.getCapability(capabilityId);
+    if (!capabilityDef) {
+        throw new EcpError(ECP_ENCODING_ERROR_CODES.FORMAT_ENCODER_NOT_FOUND, {
+            message: `Extension ${normalized} does not provide ${capabilityId}.`,
+        });
+    }
+    validateEncodeCapabilityContract(capabilityDef);
+    return capabilityDef;
+}
+/**
+ * Resolve decode capability for an extension.
+ * @category Encoding
+ */
+export function resolveDecoder(registry, extensionId) {
+    const normalized = normalizeNamespacedId(extensionId);
+    const capabilityId = `${normalized}.decode`;
+    const extensionDef = registry.getExtension(normalized);
+    if (!extensionDef) {
+        throw new EcpError(ECP_ENCODING_ERROR_CODES.FORMAT_EXTENSION_NOT_FOUND, {
+            message: `Extension ${normalized} is not registered.`,
+        });
+    }
+    const capabilityDef = registry.getCapability(capabilityId);
+    if (!capabilityDef) {
+        throw new EcpError(ECP_ENCODING_ERROR_CODES.FORMAT_DECODER_NOT_FOUND, {
+            message: `Extension ${normalized} does not provide ${capabilityId}.`,
+        });
+    }
+    validateDecodeCapabilityContract(capabilityDef);
+    return capabilityDef;
+}
+//# sourceMappingURL=resolve.js.map

package/dist/encoding/resolve.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.js","sourceRoot":"","sources":["../../src/encoding/resolve.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAA;AAG1E,OAAO,EACL,qBAAqB,EACrB,gCAAgC,EAChC,gCAAgC,GACjC,MAAM,gBAAgB,CAAA;AACvB,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAEtC;;;GAGG;AACH,MAAM,UAAU,cAAc,CAC5B,QAAkB,EAClB,WAAmB;IAEnB,MAAM,UAAU,GAAG,qBAAqB,CAAC,WAAW,CAAC,CAAA;IACrD,MAAM,YAAY,GAAG,GAAG,UAAU,SAAS,CAAA;IAE3C,MAAM,YAAY,GAAG,QAAQ,CAAC,YAAY,CAAC,UAAU,CAAC,CAAA;IACtD,IAAI,CAAC,YAAY,EAAE,CAAC;QAClB,MAAM,IAAI,QAAQ,CAAC,wBAAwB,CAAC,0BAA0B,EAAE;YACtE,OAAO,EAAE,aAAa,UAAU,qBAAqB;SACtD,CAAC,CAAA;IACJ,CAAC;IAED,MAAM,aAAa,GAAG,QAAQ,CAAC,aAAa,CAAC,YAAY,CAAC,CAAA;IAC1D,IAAI,CAAC,aAAa,EAAE,CAAC;QACnB,MAAM,IAAI,QAAQ,CAAC,wBAAwB,CAAC,wBAAwB,EAAE;YACpE,OAAO,EAAE,aAAa,UAAU,qBAAqB,YAAY,GAAG;SACrE,CAAC,CAAA;IACJ,CAAC;IAED,gCAAgC,CAAC,aAAa,CAAC,CAAA;IAC/C,OAAO,aAAa,CAAA;AACtB,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,cAAc,CAC5B,QAAkB,EAClB,WAAmB;IAEnB,MAAM,UAAU,GAAG,qBAAqB,CAAC,WAAW,CAAC,CAAA;IACrD,MAAM,YAAY,GAAG,GAAG,UAAU,SAAS,CAAA;IAE3C,MAAM,YAAY,GAAG,QAAQ,CAAC,YAAY,CAAC,UAAU,CAAC,CAAA;IACtD,IAAI,CAAC,YAAY,EAAE,CAAC;QAClB,MAAM,IAAI,QAAQ,CAAC,wBAAwB,CAAC,0BAA0B,EAAE;YACtE,OAAO,EAAE,aAAa,UAAU,qBAAqB;SACtD,CAAC,CAAA;IACJ,CAAC;IAED,MAAM,aAAa,GAAG,QAAQ,CAAC,aAAa,CAAC,YAAY,CAAC,CAAA;IAC1D,IAAI,CAAC,aAAa,EAAE,CAAC;QACnB,MAAM,IAAI,QAAQ,CAAC,wBAAwB,CAAC,wBAAwB,EAAE;YACpE,OAAO,EAAE,aAAa,UAAU,qBAAqB,YAAY,GAAG;SACrE,CAAC,CAAA;IACJ,CAAC;IAED,gCAAgC,CAAC,aAAa,CAAC,CAAA;IAC/C,OAAO,aAAa,CAAA;AACtB,CAAC"}

package/dist/encoding/schemas.d.ts

@@ -0,0 +1,398 @@
+import { z } from "zod";
+/** Zod schema for encode capability input. @category Encoding */
+export declare const ecpEncodeInputSchema: z.ZodObject<{
+    source: z.ZodUnknown;
+    sourceSchema: z.ZodOptional<z.ZodString>;
+    sourceVersion: z.ZodOptional<z.ZodString>;
+    format: z.ZodOptional<z.ZodString>;
+    options: z.ZodOptional<z.ZodObject<{
+        headers: z.ZodOptional<z.ZodBoolean>;
+        compact: z.ZodOptional<z.ZodBoolean>;
+        include: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        as: z.ZodOptional<z.ZodEnum<["object", "string"]>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        headers: z.ZodOptional<z.ZodBoolean>;
+        compact: z.ZodOptional<z.ZodBoolean>;
+        include: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        as: z.ZodOptional<z.ZodEnum<["object", "string"]>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        headers: z.ZodOptional<z.ZodBoolean>;
+        compact: z.ZodOptional<z.ZodBoolean>;
+        include: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        as: z.ZodOptional<z.ZodEnum<["object", "string"]>>;
+    }, z.ZodTypeAny, "passthrough">>>;
+}, "strip", z.ZodTypeAny, {
+    source?: unknown;
+    options?: z.objectOutputType<{
+        headers: z.ZodOptional<z.ZodBoolean>;
+        compact: z.ZodOptional<z.ZodBoolean>;
+        include: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        as: z.ZodOptional<z.ZodEnum<["object", "string"]>>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    sourceSchema?: string | undefined;
+    sourceVersion?: string | undefined;
+    format?: string | undefined;
+}, {
+    source?: unknown;
+    options?: z.objectInputType<{
+        headers: z.ZodOptional<z.ZodBoolean>;
+        compact: z.ZodOptional<z.ZodBoolean>;
+        include: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        as: z.ZodOptional<z.ZodEnum<["object", "string"]>>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    sourceSchema?: string | undefined;
+    sourceVersion?: string | undefined;
+    format?: string | undefined;
+}>;
+/** Zod schema for decode capability input. @category Encoding */
+export declare const ecpDecodeInputSchema: z.ZodObject<{
+    input: z.ZodUnknown;
+    format: z.ZodOptional<z.ZodString>;
+    targetSchema: z.ZodOptional<z.ZodString>;
+    targetVersion: z.ZodOptional<z.ZodString>;
+    options: z.ZodOptional<z.ZodObject<{
+        strict: z.ZodOptional<z.ZodBoolean>;
+        headers: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodLiteral<"auto">]>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        strict: z.ZodOptional<z.ZodBoolean>;
+        headers: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodLiteral<"auto">]>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        strict: z.ZodOptional<z.ZodBoolean>;
+        headers: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodLiteral<"auto">]>>;
+    }, z.ZodTypeAny, "passthrough">>>;
+}, "strip", z.ZodTypeAny, {
+    options?: z.objectOutputType<{
+        strict: z.ZodOptional<z.ZodBoolean>;
+        headers: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodLiteral<"auto">]>>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    input?: unknown;
+    format?: string | undefined;
+    targetSchema?: string | undefined;
+    targetVersion?: string | undefined;
+}, {
+    options?: z.objectInputType<{
+        strict: z.ZodOptional<z.ZodBoolean>;
+        headers: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodLiteral<"auto">]>>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    input?: unknown;
+    format?: string | undefined;
+    targetSchema?: string | undefined;
+    targetVersion?: string | undefined;
+}>;
+/** Zod schema for encode result output. @category Encoding */
+export declare const ecpEncodeResultSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"@executioncontrolprotocol.encode.result">;
+    version: z.ZodString;
+    success: z.ZodBoolean;
+    format: z.ZodString;
+    mediaType: z.ZodOptional<z.ZodString>;
+    sourceSchema: z.ZodOptional<z.ZodString>;
+    sourceVersion: z.ZodOptional<z.ZodString>;
+    result: z.ZodOptional<z.ZodUnknown>;
+    validation: z.ZodOptional<z.ZodObject<{
+        schema: z.ZodLiteral<"@executioncontrolprotocol.validation.result">;
+        version: z.ZodString;
+        valid: z.ZodBoolean;
+        errors: z.ZodArray<z.ZodObject<{
+            severity: z.ZodEnum<["error", "warning", "info"]>;
+            message: z.ZodString;
+            path: z.ZodOptional<z.ZodString>;
+            code: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            message: string;
+            severity: "error" | "warning" | "info";
+            code?: string | undefined;
+            path?: string | undefined;
+        }, {
+            message: string;
+            severity: "error" | "warning" | "info";
+            code?: string | undefined;
+            path?: string | undefined;
+        }>, "many">;
+        warnings: z.ZodArray<z.ZodObject<{
+            severity: z.ZodEnum<["error", "warning", "info"]>;
+            message: z.ZodString;
+            path: z.ZodOptional<z.ZodString>;
+            code: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            message: string;
+            severity: "error" | "warning" | "info";
+            code?: string | undefined;
+            path?: string | undefined;
+        }, {
+            message: string;
+            severity: "error" | "warning" | "info";
+            code?: string | undefined;
+            path?: string | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        valid: boolean;
+        version: string;
+        schema: "@executioncontrolprotocol.validation.result";
+        errors: {
+            message: string;
+            severity: "error" | "warning" | "info";
+            code?: string | undefined;
+            path?: string | undefined;
+        }[];
+        warnings: {
+            message: string;
+            severity: "error" | "warning" | "info";
+            code?: string | undefined;
+            path?: string | undefined;
+        }[];
+    }, {
+        valid: boolean;
+        version: string;
+        schema: "@executioncontrolprotocol.validation.result";
+        errors: {
+            message: string;
+            severity: "error" | "warning" | "info";
+            code?: string | undefined;
+            path?: string | undefined;
+        }[];
+        warnings: {
+            message: string;
+            severity: "error" | "warning" | "info";
+            code?: string | undefined;
+            path?: string | undefined;
+        }[];
+    }>>;
+    diagnostics: z.ZodArray<z.ZodObject<{
+        severity: z.ZodEnum<["error", "warning", "info"]>;
+        message: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        code: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        severity: "error" | "warning" | "info";
+        code?: string | undefined;
+        path?: string | undefined;
+    }, {
+        message: string;
+        severity: "error" | "warning" | "info";
+        code?: string | undefined;
+        path?: string | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    version: string;
+    schema: "@executioncontrolprotocol.encode.result";
+    format: string;
+    success: boolean;
+    diagnostics: {
+        message: string;
+        severity: "error" | "warning" | "info";
+        code?: string | undefined;
+        path?: string | undefined;
+    }[];
+    validation?: {
+        valid: boolean;
+        version: string;
+        schema: "@executioncontrolprotocol.validation.result";
+        errors: {
+            message: string;
+            severity: "error" | "warning" | "info";
+            code?: string | undefined;
+            path?: string | undefined;
+        }[];
+        warnings: {
+            message: string;
+            severity: "error" | "warning" | "info";
+            code?: string | undefined;
+            path?: string | undefined;
+        }[];
+    } | undefined;
+    sourceSchema?: string | undefined;
+    sourceVersion?: string | undefined;
+    mediaType?: string | undefined;
+    result?: unknown;
+}, {
+    version: string;
+    schema: "@executioncontrolprotocol.encode.result";
+    format: string;
+    success: boolean;
+    diagnostics: {
+        message: string;
+        severity: "error" | "warning" | "info";
+        code?: string | undefined;
+        path?: string | undefined;
+    }[];
+    validation?: {
+        valid: boolean;
+        version: string;
+        schema: "@executioncontrolprotocol.validation.result";
+        errors: {
+            message: string;
+            severity: "error" | "warning" | "info";
+            code?: string | undefined;
+            path?: string | undefined;
+        }[];
+        warnings: {
+            message: string;
+            severity: "error" | "warning" | "info";
+            code?: string | undefined;
+            path?: string | undefined;
+        }[];
+    } | undefined;
+    sourceSchema?: string | undefined;
+    sourceVersion?: string | undefined;
+    mediaType?: string | undefined;
+    result?: unknown;
+}>;
+/** Zod schema for decode result output. @category Encoding */
+export declare const ecpDecodeResultSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"@executioncontrolprotocol.decode.result">;
+    version: z.ZodString;
+    success: z.ZodBoolean;
+    targetSchema: z.ZodOptional<z.ZodString>;
+    targetVersion: z.ZodOptional<z.ZodString>;
+    result: z.ZodOptional<z.ZodUnknown>;
+    validation: z.ZodOptional<z.ZodObject<{
+        schema: z.ZodLiteral<"@executioncontrolprotocol.validation.result">;
+        version: z.ZodString;
+        valid: z.ZodBoolean;
+        errors: z.ZodArray<z.ZodObject<{
+            severity: z.ZodEnum<["error", "warning", "info"]>;
+            message: z.ZodString;
+            path: z.ZodOptional<z.ZodString>;
+            code: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            message: string;
+            severity: "error" | "warning" | "info";
+            code?: string | undefined;
+            path?: string | undefined;
+        }, {
+            message: string;
+            severity: "error" | "warning" | "info";
+            code?: string | undefined;
+            path?: string | undefined;
+        }>, "many">;
+        warnings: z.ZodArray<z.ZodObject<{
+            severity: z.ZodEnum<["error", "warning", "info"]>;
+            message: z.ZodString;
+            path: z.ZodOptional<z.ZodString>;
+            code: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            message: string;
+            severity: "error" | "warning" | "info";
+            code?: string | undefined;
+            path?: string | undefined;
+        }, {
+            message: string;
+            severity: "error" | "warning" | "info";
+            code?: string | undefined;
+            path?: string | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        valid: boolean;
+        version: string;
+        schema: "@executioncontrolprotocol.validation.result";
+        errors: {
+            message: string;
+            severity: "error" | "warning" | "info";
+            code?: string | undefined;
+            path?: string | undefined;
+        }[];
+        warnings: {
+            message: string;
+            severity: "error" | "warning" | "info";
+            code?: string | undefined;
+            path?: string | undefined;
+        }[];
+    }, {
+        valid: boolean;
+        version: string;
+        schema: "@executioncontrolprotocol.validation.result";
+        errors: {
+            message: string;
+            severity: "error" | "warning" | "info";
+            code?: string | undefined;
+            path?: string | undefined;
+        }[];
+        warnings: {
+            message: string;
+            severity: "error" | "warning" | "info";
+            code?: string | undefined;
+            path?: string | undefined;
+        }[];
+    }>>;
+    diagnostics: z.ZodArray<z.ZodObject<{
+        severity: z.ZodEnum<["error", "warning", "info"]>;
+        message: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        code: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        severity: "error" | "warning" | "info";
+        code?: string | undefined;
+        path?: string | undefined;
+    }, {
+        message: string;
+        severity: "error" | "warning" | "info";
+        code?: string | undefined;
+        path?: string | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    version: string;
+    schema: "@executioncontrolprotocol.decode.result";
+    success: boolean;
+    diagnostics: {
+        message: string;
+        severity: "error" | "warning" | "info";
+        code?: string | undefined;
+        path?: string | undefined;
+    }[];
+    validation?: {
+        valid: boolean;
+        version: string;
+        schema: "@executioncontrolprotocol.validation.result";
+        errors: {
+            message: string;
+            severity: "error" | "warning" | "info";
+            code?: string | undefined;
+            path?: string | undefined;
+        }[];
+        warnings: {
+            message: string;
+            severity: "error" | "warning" | "info";
+            code?: string | undefined;
+            path?: string | undefined;
+        }[];
+    } | undefined;
+    targetSchema?: string | undefined;
+    targetVersion?: string | undefined;
+    result?: unknown;
+}, {
+    version: string;
+    schema: "@executioncontrolprotocol.decode.result";
+    success: boolean;
+    diagnostics: {
+        message: string;
+        severity: "error" | "warning" | "info";
+        code?: string | undefined;
+        path?: string | undefined;
+    }[];
+    validation?: {
+        valid: boolean;
+        version: string;
+        schema: "@executioncontrolprotocol.validation.result";
+        errors: {
+            message: string;
+            severity: "error" | "warning" | "info";
+            code?: string | undefined;
+            path?: string | undefined;
+        }[];
+        warnings: {
+            message: string;
+            severity: "error" | "warning" | "info";
+            code?: string | undefined;
+            path?: string | undefined;
+        }[];
+    } | undefined;
+    targetSchema?: string | undefined;
+    targetVersion?: string | undefined;
+    result?: unknown;
+}>;
+/** Default encoded version field. @category Encoding */
+export declare const ENCODED_VERSION: "1.0";
+//# sourceMappingURL=schemas.d.ts.map

package/dist/encoding/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/encoding/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAoBvB,iEAAiE;AACjE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAc/B,CAAA;AAEF,iEAAiE;AACjE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAY/B,CAAA;AAEF,8DAA8D;AAC9D,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWhC,CAAA;AAEF,8DAA8D;AAC9D,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAShC,CAAA;AAEF,wDAAwD;AACxD,eAAO,MAAM,eAAe,OAAqB,CAAA"}

package/dist/encoding/schemas.js

@@ -0,0 +1,74 @@
+import { z } from "zod";
+import { LATEST_ECP_VERSION } from "@executioncontrolprotocol/types";
+const validationIssueSchema = z.object({
+    severity: z.enum(["error", "warning", "info"]),
+    message: z.string(),
+    path: z.string().optional(),
+    code: z.string().optional(),
+});
+const validationResultSchema = z
+    .object({
+    schema: z.literal("@executioncontrolprotocol.validation.result"),
+    version: z.string(),
+    valid: z.boolean(),
+    errors: z.array(validationIssueSchema),
+    warnings: z.array(validationIssueSchema),
+})
+    .optional();
+/** Zod schema for encode capability input. @category Encoding */
+export const ecpEncodeInputSchema = z.object({
+    source: z.unknown(),
+    sourceSchema: z.string().optional(),
+    sourceVersion: z.string().optional(),
+    format: z.string().optional(),
+    options: z
+        .object({
+        headers: z.boolean().optional(),
+        compact: z.boolean().optional(),
+        include: z.array(z.string()).optional(),
+        as: z.enum(["object", "string"]).optional(),
+    })
+        .passthrough()
+        .optional(),
+});
+/** Zod schema for decode capability input. @category Encoding */
+export const ecpDecodeInputSchema = z.object({
+    input: z.unknown(),
+    format: z.string().optional(),
+    targetSchema: z.string().optional(),
+    targetVersion: z.string().optional(),
+    options: z
+        .object({
+        strict: z.boolean().optional(),
+        headers: z.union([z.boolean(), z.literal("auto")]).optional(),
+    })
+        .passthrough()
+        .optional(),
+});
+/** Zod schema for encode result output. @category Encoding */
+export const ecpEncodeResultSchema = z.object({
+    schema: z.literal("@executioncontrolprotocol.encode.result"),
+    version: z.string(),
+    success: z.boolean(),
+    format: z.string(),
+    mediaType: z.string().optional(),
+    sourceSchema: z.string().optional(),
+    sourceVersion: z.string().optional(),
+    result: z.unknown().optional(),
+    validation: validationResultSchema,
+    diagnostics: z.array(validationIssueSchema),
+});
+/** Zod schema for decode result output. @category Encoding */
+export const ecpDecodeResultSchema = z.object({
+    schema: z.literal("@executioncontrolprotocol.decode.result"),
+    version: z.string(),
+    success: z.boolean(),
+    targetSchema: z.string().optional(),
+    targetVersion: z.string().optional(),
+    result: z.unknown().optional(),
+    validation: validationResultSchema,
+    diagnostics: z.array(validationIssueSchema),
+});
+/** Default encoded version field. @category Encoding */
+export const ENCODED_VERSION = LATEST_ECP_VERSION;
+//# sourceMappingURL=schemas.js.map

package/dist/encoding/schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.js","sourceRoot":"","sources":["../../src/encoding/schemas.ts"],"names":[],"mappings":"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"}