@alpacakit/channels 0.1.0-beta.37 → 0.2.0-beta.2

package/dist/index.js

@@ -1,5 +1,5 @@
 export * from "./codecs.js";
-export * from "./contract.js";
+export { createOutputContract, EntryOutputContractError, requireEntryOutput, verifyEntryOutput, } from "./contract.js";
 export * from "./factory.js";
 export * from "./introspection.js";
 export * from "./model.js";

package/dist/input-compiler.d.ts

@@ -0,0 +1,13 @@
+import type { CompiledParameterBinding } from "./binding-compiler.js";
+import type { ErasedEntryDefinition, ErasedParameterDefinition, ParameterValues, RawValueMap } from "./model.js";
+import type { InputPlan } from "./registration.js";
+export type InputCoercer = (parameter: ErasedParameterDefinition, raw: unknown) => unknown;
+export type CompiledInputPlan<Values extends RawValueMap = RawValueMap, Input = unknown> = InputPlan<Values, Input> & {
+    readonly parameterNames: readonly string[];
+    readonly parseCoerced: (raw: RawValueMap, coerce: InputCoercer) => Input;
+};
+export declare function compileInputPlan<const Entry extends ErasedEntryDefinition, Values extends RawValueMap = ParameterValues<Entry["parameters"]>>(input: {
+    readonly entry: Entry;
+    readonly bindings: readonly CompiledParameterBinding[];
+}): CompiledInputPlan<Values, ReturnType<Entry["project"]>>;
+//# sourceMappingURL=input-compiler.d.ts.map

package/dist/input-compiler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input-compiler.d.ts","sourceRoot":"","sources":["../src/input-compiler.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEtE,OAAO,KAAK,EACV,qBAAqB,EACrB,yBAAyB,EACzB,eAAe,EACf,WAAW,EACZ,MAAM,YAAY,CAAC;AAEpB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAOnD,MAAM,MAAM,YAAY,GAAG,CACzB,SAAS,EAAE,yBAAyB,EACpC,GAAG,EAAE,OAAO,KACT,OAAO,CAAC;AAEb,MAAM,MAAM,iBAAiB,CAC3B,MAAM,SAAS,WAAW,GAAG,WAAW,EACxC,KAAK,GAAG,OAAO,IACb,SAAS,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG;IAC7B,QAAQ,CAAC,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C,QAAQ,CAAC,YAAY,EAAE,CAAC,GAAG,EAAE,WAAW,EAAE,MAAM,EAAE,YAAY,KAAK,KAAK,CAAC;CAC1E,CAAC;AAEF,wBAAgB,gBAAgB,CAC9B,KAAK,CAAC,KAAK,SAAS,qBAAqB,EACzC,MAAM,SAAS,WAAW,GAAG,eAAe,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC,EACjE,KAAK,EAAE;IACP,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,SAAS,wBAAwB,EAAE,CAAC;CACxD,GAAG,iBAAiB,CAAC,MAAM,EAAE,UAAU,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,CA4B1D"}

package/dist/input-compiler.js

@@ -0,0 +1,122 @@
+import { z } from "zod";
+import { EntryTreeDefinitionError } from "./definition-error.js";
+import { copyJsonValue, ownedRecord } from "./owned.js";
+import { EntryInputError } from "./runtime.js";
+import { ENTRY_INPUT_TARGET_KIND, PARAMETER_REQUIREMENT_KIND, } from "./values.js";
+export function compileInputPlan(input) {
+    validateDefaults(input.entry);
+    const exposedNames = input.bindings.map((binding) => binding.parameter.name);
+    const exposed = new Set(exposedNames);
+    const schema = buildInputSchema(input.bindings);
+    const project = (values) => projectEntry(input.entry, exposed, values);
+    const parseValues = (raw, coerce) => {
+        rejectUnknownKeys(raw, exposed);
+        const candidate = coerce
+            ? coerceRawValues(raw, input.bindings, coerce)
+            : raw;
+        const parsed = schema.safeParse(candidate);
+        if (!parsed.success) {
+            throw entryInputError(parsed.error);
+        }
+        return project(parsed.data);
+    };
+    return ownedRecord({
+        schema: schema,
+        parse: (raw) => parseValues(raw),
+        parseCoerced: (raw, coerce) => parseValues(raw, coerce),
+        project,
+        parameterNames: Object.freeze(exposedNames),
+    });
+}
+function buildInputSchema(bindings) {
+    const shape = Object.create(null);
+    for (const { parameter } of bindings) {
+        let schema = parameter.codec.schema;
+        switch (parameter.requirement.kind) {
+            case PARAMETER_REQUIREMENT_KIND.required:
+                break;
+            case PARAMETER_REQUIREMENT_KIND.optional:
+                schema = schema.optional();
+                break;
+            case PARAMETER_REQUIREMENT_KIND.optionalWithDefault: {
+                const authoredDefault = parameter.requirement.defaultValue;
+                schema = schema.prefault(() => copyJsonValue(authoredDefault));
+                break;
+            }
+        }
+        schema = schema.describe(parameter.description);
+        Reflect.set(shape, parameter.name, schema);
+    }
+    return z.object(shape).strict();
+}
+function validateDefaults(entry) {
+    const issues = [];
+    for (const parameter of entry.parameters) {
+        if (parameter.requirement.kind !==
+            PARAMETER_REQUIREMENT_KIND.optionalWithDefault) {
+            continue;
+        }
+        const parsed = parameter.codec.schema.safeParse(copyJsonValue(parameter.requirement.defaultValue));
+        if (!parsed.success) {
+            issues.push(`${entry.name}#${parameter.name}: invalid authored default: ${formatZodIssues(parsed.error)}`);
+        }
+    }
+    if (issues.length > 0) {
+        throw new EntryTreeDefinitionError(issues);
+    }
+}
+function projectEntry(entry, exposed, publicValues) {
+    const values = Object.create(null);
+    for (const parameter of entry.parameters) {
+        if (exposed.has(parameter.name)) {
+            if (Object.hasOwn(publicValues, parameter.name)) {
+                Reflect.set(values, parameter.name, Reflect.get(publicValues, parameter.name));
+            }
+            continue;
+        }
+        if (parameter.requirement.kind ===
+            PARAMETER_REQUIREMENT_KIND.optionalWithDefault) {
+            const parsed = parameter.codec.schema.safeParse(copyJsonValue(parameter.requirement.defaultValue));
+            if (!parsed.success) {
+                throw new Error(`Compiled default became invalid for ${entry.name}#${parameter.name}`);
+            }
+            Reflect.set(values, parameter.name, parsed.data);
+        }
+    }
+    const project = entry.project;
+    return project({ values: values });
+}
+function rejectUnknownKeys(raw, exposed) {
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+        throw new EntryInputError(["Entry input must be an object"]);
+    }
+    const unknown = Object.keys(raw).filter((key) => !exposed.has(key));
+    if (unknown.length > 0) {
+        throw new EntryInputError(unknown.map((key) => `Unknown parameter ${key}`));
+    }
+}
+function coerceRawValues(raw, bindings, coerce) {
+    const output = Object.create(null);
+    for (const binding of bindings) {
+        const name = binding.parameter.name;
+        if (!Object.hasOwn(raw, name)) {
+            continue;
+        }
+        Reflect.set(output, name, coerce(binding.parameter, Reflect.get(raw, name)));
+    }
+    return output;
+}
+function entryInputError(error) {
+    const first = error.issues[0];
+    const firstPath = first?.path[0];
+    const target = typeof firstPath === "string"
+        ? {
+            kind: ENTRY_INPUT_TARGET_KIND.parameter,
+            parameterName: firstPath,
+        }
+        : { kind: ENTRY_INPUT_TARGET_KIND.entry };
+    return new EntryInputError(error.issues.map((issue) => issue.message), target);
+}
+function formatZodIssues(error) {
+    return error.issues.map((issue) => issue.message).join("; ");
+}

package/dist/introspection.d.ts

@@ -1,6 +1,6 @@
 import type { JsonValue } from "@alpacakit/core";
 import type { CommandDocumentation, EntryTreeDefinition, ErasedEntryDefinition, ValueShape } from "./model.js";
-import { ENTRY_OUTPUT_DESCRIPTION_KIND, type PARAMETER_REQUIREMENT_KIND } from "./values.js";
+import { ENTRY_OUTPUT_DESCRIPTION_KIND, PARAMETER_REQUIREMENT_KIND } from "./values.js";
 export type CommandPath = readonly string[];
 export type ParameterRequirementDescription = {
     readonly kind: typeof PARAMETER_REQUIREMENT_KIND.required;

package/dist/introspection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"introspection.d.ts","sourceRoot":"","sources":["../src/introspection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,KAAK,EACV,oBAAoB,EACpB,mBAAmB,EAEnB,qBAAqB,EACrB,UAAU,EACX,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,6BAA6B,EAC7B,KAAK,0BAA0B,EAChC,MAAM,aAAa,CAAC;AAOrB,MAAM,MAAM,WAAW,GAAG,SAAS,MAAM,EAAE,CAAC;AAE5C,MAAM,MAAM,+BAA+B,GACvC;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,0BAA0B,CAAC,QAAQ,CAAA;CAAE,GAC7D;IACE,QAAQ,CAAC,IAAI,EAAE,OAAO,0BAA0B,CAAC,QAAQ,CAAC;CAC3D,GACD;IACE,QAAQ,CAAC,IAAI,EAAE,OAAO,0BAA0B,CAAC,mBAAmB,CAAC;IACrE,QAAQ,CAAC,YAAY,EAAE,SAAS,CAAC;CAClC,CAAC;AAEN,MAAM,MAAM,oBAAoB,GAAG;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,WAAW,EAAE,+BAA+B,CAAC;IACtD,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAC9B;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,6BAA6B,CAAC,KAAK,CAAA;CAAE,GAC7D;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,6BAA6B,CAAC,IAAI,CAAA;CAAE,CAAC;AAEjE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,UAAU,EAAE,SAAS,oBAAoB,EAAE,CAAC;IACrD,QAAQ,CAAC,MAAM,EAAE,sBAAsB,CAAC;CACzC,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,aAAa,EAAE,oBAAoB,CAAC;IAC7C,QAAQ,CAAC,SAAS,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAChD,QAAQ,CAAC,QAAQ,EAAE,SAAS,kBAAkB,EAAE,CAAC;CAClD,CAAC;AAOF,wBAAgB,aAAa,CAAC,KAAK,EAAE,qBAAqB,GAAG,gBAAgB,CAgB5E;AAED,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,mBAAmB,GACxB,kBAAkB,CAiCpB;AAED,wBAAgB,4BAA4B,CAC1C,WAAW,EAAE,qBAAqB,CAAC,YAAY,CAAC,CAAC,MAAM,CAAC,CAAC,aAAa,CAAC,GACtE,+BAA+B,CAEjC"}
+{"version":3,"file":"introspection.d.ts","sourceRoot":"","sources":["../src/introspection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,KAAK,EACV,oBAAoB,EACpB,mBAAmB,EAEnB,qBAAqB,EACrB,UAAU,EACX,MAAM,YAAY,CAAC;AAYpB,OAAO,EACL,6BAA6B,EAC7B,0BAA0B,EAC3B,MAAM,aAAa,CAAC;AAOrB,MAAM,MAAM,WAAW,GAAG,SAAS,MAAM,EAAE,CAAC;AAE5C,MAAM,MAAM,+BAA+B,GACvC;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,0BAA0B,CAAC,QAAQ,CAAA;CAAE,GAC7D;IACE,QAAQ,CAAC,IAAI,EAAE,OAAO,0BAA0B,CAAC,QAAQ,CAAC;CAC3D,GACD;IACE,QAAQ,CAAC,IAAI,EAAE,OAAO,0BAA0B,CAAC,mBAAmB,CAAC;IACrE,QAAQ,CAAC,YAAY,EAAE,SAAS,CAAC;CAClC,CAAC;AAEN,MAAM,MAAM,oBAAoB,GAAG;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,WAAW,EAAE,+BAA+B,CAAC;IACtD,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAC9B;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,6BAA6B,CAAC,KAAK,CAAA;CAAE,GAC7D;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,6BAA6B,CAAC,IAAI,CAAA;CAAE,CAAC;AAEjE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,UAAU,EAAE,SAAS,oBAAoB,EAAE,CAAC;IACrD,QAAQ,CAAC,MAAM,EAAE,sBAAsB,CAAC;CACzC,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,aAAa,EAAE,oBAAoB,CAAC;IAC7C,QAAQ,CAAC,SAAS,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAChD,QAAQ,CAAC,QAAQ,EAAE,SAAS,kBAAkB,EAAE,CAAC;CAClD,CAAC;AAOF,wBAAgB,aAAa,CAAC,KAAK,EAAE,qBAAqB,GAAG,gBAAgB,CAoB5E;AAED,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,mBAAmB,GACxB,kBAAkB,CA4CpB;AAED,wBAAgB,4BAA4B,CAC1C,WAAW,EAAE,qBAAqB,CAAC,YAAY,CAAC,CAAC,MAAM,CAAC,CAAC,aAAa,CAAC,GACtE,+BAA+B,CAWjC"}

package/dist/introspection.js

@@ -1,49 +1,54 @@
-import { visitEntryTree } from "./schema.js";
-import { ENTRY_OUTPUT_DESCRIPTION_KIND, } from "./values.js";
+import { ownedArray, ownedRecord, snapshotJsonValue, snapshotValueShape, } from "./owned.js";
+import { EntryTreeDefinitionError, validateEntryTreeStructure, visitEntryTree, } from "./schema.js";
+import { ENTRY_OUTPUT_DESCRIPTION_KIND, PARAMETER_REQUIREMENT_KIND, } from "./values.js";
 const ENTRY_INTROSPECTION_ERROR = {
     missingChild: "Entry tree child could not be described",
     missingRoot: "Entry tree root could not be described",
 };
 export function describeEntry(entry) {
-    return {
+    return ownedRecord({
         name: entry.name,
-        parameters: entry.parameters.map((parameter) => ({
+        parameters: ownedArray(entry.parameters.map((parameter) => ownedRecord({
             name: parameter.name,
             description: parameter.description,
             requirement: describeParameterRequirement(parameter.requirement),
-            shape: parameter.codec.shape,
-        })),
-        output: {
+            shape: snapshotValueShape(parameter.codec.shape),
+        }))),
+        output: ownedRecord({
             kind: entry.output === null
                 ? ENTRY_OUTPUT_DESCRIPTION_KIND.none
                 : ENTRY_OUTPUT_DESCRIPTION_KIND.typed,
-        },
-    };
+        }),
+    });
 }
 export function describeEntryTree(tree) {
+    const issues = validateEntryTreeStructure(tree);
+    if (issues.length > 0) {
+        throw new EntryTreeDefinitionError(issues);
+    }
     const frames = new Map();
     const entries = [];
     visitEntryTree(tree, {
         visitNode(node, path) {
-            entries.push({ node, path: path.slice(1) });
+            entries.push({ node, path: ownedArray(path.slice(1)) });
         },
         visitEndpoint() { },
     });
     for (const current of entries.reverse()) {
-        frames.set(current.node, {
+        frames.set(current.node, ownedRecord({
             path: current.path,
             name: current.node.name,
             description: current.node.description,
             documentation: current.node.documentation,
-            endpoints: current.node.endpoints.map((endpoint) => describeEntry(endpoint.entry)),
-            children: current.node.children.map((child) => {
+            endpoints: ownedArray(current.node.endpoints.map((endpoint) => describeEntry(endpoint.entry))),
+            children: ownedArray(current.node.children.map((child) => {
                 const description = frames.get(child);
                 if (description === undefined) {
                     throw new Error(ENTRY_INTROSPECTION_ERROR.missingChild);
                 }
                 return description;
-            }),
-        });
+            })),
+        }));
     }
     const root = frames.get(tree.root);
     if (root === undefined) {
@@ -52,5 +57,14 @@ export function describeEntryTree(tree) {
     return root;
 }
 export function describeParameterRequirement(requirement) {
-    return requirement;
+    switch (requirement.kind) {
+        case PARAMETER_REQUIREMENT_KIND.required:
+        case PARAMETER_REQUIREMENT_KIND.optional:
+            return ownedRecord({ kind: requirement.kind });
+        case PARAMETER_REQUIREMENT_KIND.optionalWithDefault:
+            return ownedRecord({
+                kind: requirement.kind,
+                defaultValue: snapshotJsonValue(requirement.defaultValue),
+            });
+    }
 }

package/dist/mcp.d.ts

@@ -1,26 +1,27 @@
-import type { JsonObject } from "@alpacakit/core";
-import type { z } from "zod";
-import type { EntryChannelBinding, EntryDefinitionWithOutput, EntryTreeEndpoint, ParameterSet, RawValueMap } from "./model.js";
-import { type EntryDecodeResult } from "./runtime.js";
-import { CHANNEL, ENTRY_DECODE_RESULT_KIND } from "./values.js";
-export type McpBinding<Parameters extends ParameterSet = ParameterSet> = readonly Parameters[number]["name"][];
-export declare function bindMcpEntry<const ParameterNames extends readonly string[]>(...parameterNames: ParameterNames): EntryChannelBinding<typeof CHANNEL.mcp, ParameterNames[number]>;
-export type McpEntryParseResult<Entry extends EntryTreeEndpoint["entry"]> = EntryDecodeResult<ReturnType<Entry["project"]>>;
-export type McpResolvedEntry<Entry extends EntryTreeEndpoint["entry"]> = Extract<McpEntryParseResult<Entry>, {
-    readonly kind: typeof ENTRY_DECODE_RESULT_KIND.resolved;
-}>;
-/**
- * A compiled MCP endpoint. The binding is validated and compiled once by
- * `createMcpEndpoint()`, so definition errors surface eagerly (like the CLI
- * router) and `parse()` does no per-invocation recompilation.
- */
-export interface McpEndpoint<Entry extends EntryTreeEndpoint["entry"]> {
-    /** Raw Zod object shape for MCP tool registration. */
-    readonly inputSchema: Record<string, z.ZodType>;
-    /** Decode and project one MCP invocation through the endpoint. */
-    parse(raw: RawValueMap): McpEntryParseResult<Entry>;
+import { type ParameterDescription } from "./introspection.js";
+import type { EntryChannelBinding, RawValueMap } from "./model.js";
+import type { InputPlan, Registration } from "./registration.js";
+import { type ContextFor, type EndpointForChannel, type EndpointsOfSource, type EntryTreeSource, type OutputFor } from "./registration.js";
+import { CHANNEL } from "./values.js";
+export type McpBinding<Name extends string = string, Excluded extends readonly string[] = readonly string[]> = {
+    readonly name: Name;
+    readonly exclude: Excluded;
+};
+export declare function bindMcpEntry<const Name extends string, const Excluded extends readonly string[] = readonly []>(input: {
+    readonly name: Name;
+    readonly exclude?: Excluded;
+}): EntryChannelBinding<typeof CHANNEL.mcp, McpBinding<Name, Excluded>>;
+export type McpRegistration<Values extends RawValueMap, Input, Context, Output> = Omit<Registration<Values, Input, Context, Output>, "binding"> & {
+    readonly binding: EntryChannelBinding<typeof CHANNEL.mcp, McpBinding>;
+    readonly name: string;
+    readonly parameters: readonly ParameterDescription[];
+    readonly input: InputPlan<Values, Input>;
+};
+export interface McpToolCollection<Context, Output> {
+    readonly length: number;
+    readonly forEach: (visit: <Values extends RawValueMap, Input>(item: McpRegistration<Values, Input, Context, Output>) => void) => void;
 }
-export declare function createMcpEndpoint<const Entry extends EntryTreeEndpoint["entry"]>(endpoint: EntryTreeEndpoint<Entry>): McpEndpoint<Entry>;
-export declare function isMcpResolved<Entry extends EntryTreeEndpoint["entry"]>(result: McpEntryParseResult<Entry>): result is McpResolvedEntry<Entry>;
-export declare function createMcpOutputSchema<const Name extends string, const Parameters extends ParameterSet, Projection, Output extends JsonObject>(endpoint: EntryTreeEndpoint<EntryDefinitionWithOutput<Name, Parameters, Projection, Output>>): z.ZodType<Output>;
+type McpEndpointFor<Source extends EntryTreeSource> = EndpointForChannel<EndpointsOfSource<Source>, typeof CHANNEL.mcp>;
+export declare function collectMcpTools<const Source extends EntryTreeSource>(source: Source): McpToolCollection<ContextFor<McpEndpointFor<Source>>, OutputFor<McpEndpointFor<Source>>>;
+export {};
 //# sourceMappingURL=mcp.d.ts.map

package/dist/mcp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../src/mcp.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQ7B,OAAO,KAAK,EACV,mBAAmB,EACnB,yBAAyB,EACzB,iBAAiB,EACjB,YAAY,EACZ,WAAW,EACZ,MAAM,YAAY,CAAC;AACpB,OAAO,EAAoB,KAAK,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAQxE,OAAO,EACL,OAAO,EACP,wBAAwB,EAEzB,MAAM,aAAa,CAAC;AAOrB,MAAM,MAAM,UAAU,CAAC,UAAU,SAAS,YAAY,GAAG,YAAY,IACnE,SAAS,UAAU,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC;AAExC,wBAAgB,YAAY,CAAC,KAAK,CAAC,cAAc,SAAS,SAAS,MAAM,EAAE,EACzE,GAAG,cAAc,EAAE,cAAc,GAChC,mBAAmB,CAAC,OAAO,OAAO,CAAC,GAAG,EAAE,cAAc,CAAC,MAAM,CAAC,CAAC,CAGjE;AAED,MAAM,MAAM,mBAAmB,CAAC,KAAK,SAAS,iBAAiB,CAAC,OAAO,CAAC,IACtE,iBAAiB,CAAC,UAAU,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;AAElD,MAAM,MAAM,gBAAgB,CAAC,KAAK,SAAS,iBAAiB,CAAC,OAAO,CAAC,IACnE,OAAO,CACL,mBAAmB,CAAC,KAAK,CAAC,EAC1B;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,wBAAwB,CAAC,QAAQ,CAAA;CAAE,CAC5D,CAAC;AAEJ;;;;GAIG;AACH,MAAM,WAAW,WAAW,CAAC,KAAK,SAAS,iBAAiB,CAAC,OAAO,CAAC;IACnE,sDAAsD;IACtD,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC;IAChD,kEAAkE;IAClE,KAAK,CAAC,GAAG,EAAE,WAAW,GAAG,mBAAmB,CAAC,KAAK,CAAC,CAAC;CACrD;AAED,wBAAgB,iBAAiB,CAC/B,KAAK,CAAC,KAAK,SAAS,iBAAiB,CAAC,OAAO,CAAC,EAC9C,QAAQ,EAAE,iBAAiB,CAAC,KAAK,CAAC,GAAG,WAAW,CAAC,KAAK,CAAC,CAaxD;AAED,wBAAgB,aAAa,CAAC,KAAK,SAAS,iBAAiB,CAAC,OAAO,CAAC,EACpE,MAAM,EAAE,mBAAmB,CAAC,KAAK,CAAC,GACjC,MAAM,IAAI,gBAAgB,CAAC,KAAK,CAAC,CAEnC;AAmED,wBAAgB,qBAAqB,CACnC,KAAK,CAAC,IAAI,SAAS,MAAM,EACzB,KAAK,CAAC,UAAU,SAAS,YAAY,EACrC,UAAU,EACV,MAAM,SAAS,UAAU,EAEzB,QAAQ,EAAE,iBAAiB,CACzB,yBAAyB,CAAC,IAAI,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,CAAC,CAChE,GACA,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAWnB"}
+{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../src/mcp.ts"],"names":[],"mappings":"AAMA,OAAO,EAAiB,KAAK,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAC9E,OAAO,KAAK,EACV,mBAAmB,EAEnB,WAAW,EACZ,MAAM,YAAY,CAAC;AAEpB,OAAO,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjE,OAAO,EACL,KAAK,UAAU,EACf,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,SAAS,EAEf,MAAM,mBAAmB,CAAC;AAa3B,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAEtC,MAAM,MAAM,UAAU,CACpB,IAAI,SAAS,MAAM,GAAG,MAAM,EAC5B,QAAQ,SAAS,SAAS,MAAM,EAAE,GAAG,SAAS,MAAM,EAAE,IACpD;IACF,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IACpB,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC;CAC5B,CAAC;AAEF,wBAAgB,YAAY,CAC1B,KAAK,CAAC,IAAI,SAAS,MAAM,EACzB,KAAK,CAAC,QAAQ,SAAS,SAAS,MAAM,EAAE,GAAG,SAAS,EAAE,EACtD,KAAK,EAAE;IACP,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IACpB,QAAQ,CAAC,OAAO,CAAC,EAAE,QAAQ,CAAC;CAC7B,GAAG,mBAAmB,CAAC,OAAO,OAAO,CAAC,GAAG,EAAE,UAAU,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAOtE;AAED,MAAM,MAAM,eAAe,CACzB,MAAM,SAAS,WAAW,EAC1B,KAAK,EACL,OAAO,EACP,MAAM,IACJ,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,SAAS,CAAC,GAAG;IAClE,QAAQ,CAAC,OAAO,EAAE,mBAAmB,CAAC,OAAO,OAAO,CAAC,GAAG,EAAE,UAAU,CAAC,CAAC;IACtE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,UAAU,EAAE,SAAS,oBAAoB,EAAE,CAAC;IACrD,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;CAC1C,CAAC;AAEF,MAAM,WAAW,iBAAiB,CAAC,OAAO,EAAE,MAAM;IAChD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,OAAO,EAAE,CAChB,KAAK,EAAE,CAAC,MAAM,SAAS,WAAW,EAAE,KAAK,EACvC,IAAI,EAAE,eAAe,CAAC,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,CAAC,KAClD,IAAI,KACN,IAAI,CAAC;CACX;AAED,KAAK,cAAc,CAAC,MAAM,SAAS,eAAe,IAAI,kBAAkB,CACtE,iBAAiB,CAAC,MAAM,CAAC,EACzB,OAAO,OAAO,CAAC,GAAG,CACnB,CAAC;AAOF,wBAAgB,eAAe,CAAC,KAAK,CAAC,MAAM,SAAS,eAAe,EAClE,MAAM,EAAE,MAAM,GACb,iBAAiB,CAClB,UAAU,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,EAClC,SAAS,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,CAClC,CA0CA"}

package/dist/mcp.js

@@ -1,67 +1,99 @@
-import { compileParameterBindings, PARAMETER_BINDING_ISSUE_KIND, } from "./binding-compiler.js";
-import { requireEntryOutput } from "./contract.js";
-import { decodeEntryInput } from "./runtime.js";
-import { EntryTreeDefinitionError, findChannelBinding } from "./schema.js";
+import { compileParameterExclusions, PARAMETER_BINDING_ISSUE_KIND, } from "./binding-compiler.js";
+import { compileInputPlan } from "./input-compiler.js";
+import { describeEntry } from "./introspection.js";
+import { ownedArray, ownedRecord } from "./owned.js";
+import { packRegistrationCollection, } from "./registration.js";
+import { EntryTreeDefinitionError, findChannelBinding, validateEntryTreeStructure, visitEntryTreeSource, } from "./schema.js";
 import { createEntryChannelBinding, isChannelPayload, PAYLOAD_KIND, registerChannelPayload, } from "./tree-internal.js";
-import { CHANNEL, ENTRY_DECODE_RESULT_KIND, PARAMETER_REQUIREMENT_KIND, } from "./values.js";
-const ZOD_SCHEMA_TYPE = {
-    object: "object",
-    readonly: "readonly",
-};
-export function bindMcpEntry(...parameterNames) {
-    registerChannelPayload(PAYLOAD_KIND.mcpBinding, parameterNames);
-    return createEntryChannelBinding(CHANNEL.mcp, parameterNames);
+import { CHANNEL } from "./values.js";
+export function bindMcpEntry(input) {
+    const payload = ownedRecord({
+        name: input.name,
+        exclude: ownedArray(input.exclude ?? []),
+    });
+    registerChannelPayload(PAYLOAD_KIND.mcpBinding, payload);
+    return createEntryChannelBinding(CHANNEL.mcp, payload);
 }
-export function createMcpEndpoint(endpoint) {
-    const bindings = resolveMcpBindings(endpoint);
-    const parameterNames = bindings.map((binding) => binding.parameter.name);
-    const inputSchema = buildMcpInputSchema(bindings);
-    return {
-        inputSchema,
-        parse: (raw) => decodeEntryInput({
-            entry: endpoint.entry,
-            parameterNames,
-            raw,
-        }),
-    };
-}
-export function isMcpResolved(result) {
-    return result.kind === ENTRY_DECODE_RESULT_KIND.resolved;
-}
-function buildMcpInputSchema(bindings) {
-    const shape = {};
-    for (const binding of bindings) {
-        const { parameter } = binding;
-        const describedSchema = parameter.codec.schema.describe(parameter.description);
-        shape[parameter.name] =
-            parameter.requirement.kind !== PARAMETER_REQUIREMENT_KIND.required
-                ? describedSchema.optional()
-                : describedSchema;
+export function collectMcpTools(source) {
+    const structuralIssues = validateEntryTreeStructure(source);
+    if (structuralIssues.length > 0) {
+        throw new EntryTreeDefinitionError(structuralIssues);
+    }
+    const issues = [];
+    const registrations = [];
+    const seenEndpoints = new Set();
+    visitEntryTreeSource(source, {
+        visitNode() { },
+        visitEndpoint(endpoint) {
+            if (seenEndpoints.has(endpoint)) {
+                return;
+            }
+            const channelBinding = findChannelBinding(endpoint, CHANNEL.mcp);
+            if (channelBinding === null) {
+                return;
+            }
+            seenEndpoints.add(endpoint);
+            if (!isMcpChannelBinding(channelBinding)) {
+                issues.push(`${endpoint.entry.name}: invalid MCP binding`);
+                return;
+            }
+            const registration = compileMcpRegistration(endpoint, channelBinding, channelBinding.binding, issues);
+            registrations.push(registration);
+        },
+    });
+    validateMcpNames(registrations, issues);
+    if (issues.length > 0) {
+        throw new EntryTreeDefinitionError(issues);
     }
-    return shape;
+    return packRegistrationCollection(registrations);
 }
-function resolveMcpBindings(endpoint) {
-    const channelBindings = endpoint.channels.filter((candidate) => candidate.channel === CHANNEL.mcp);
-    const channelBinding = findChannelBinding(endpoint, CHANNEL.mcp);
-    if (channelBindings.length !== 1 ||
-        !channelBinding ||
-        !isMcpBinding(channelBinding.binding)) {
-        throw new EntryTreeDefinitionError([
-            `${endpoint.entry.name}: endpoint must have exactly one valid MCP binding`,
-        ]);
+function compileMcpRegistration(endpoint, channelBinding, binding, issues) {
+    if (binding.name.trim().length === 0) {
+        issues.push(`${endpoint.entry.name}: MCP name must not be blank`);
     }
-    const compilation = compileParameterBindings(endpoint.entry, channelBinding.binding.map((parameterName) => ({ parameterName })));
-    if (compilation.issues.length > 0) {
-        throw new EntryTreeDefinitionError(compilation.issues.map((issue) => formatMcpParameterBindingIssue(endpoint.entry.name, issue)));
+    const compilation = compileParameterExclusions(endpoint.entry, binding.exclude);
+    issues.push(...compilation.issues.map((issue) => formatMcpParameterBindingIssue(endpoint.entry.name, issue)));
+    const input = compileInputPlan({
+        entry: endpoint.entry,
+        bindings: compilation.bindings,
+    });
+    const exposed = new Set(input.parameterNames);
+    return ownedRecord({
+        endpoint,
+        entry: endpoint.entry,
+        binding: channelBinding,
+        name: binding.name,
+        parameters: ownedArray(describeEntry(endpoint.entry).parameters.filter((parameter) => exposed.has(parameter.name))),
+        input: ownedRecord({
+            schema: input.schema,
+            parse: input.parse,
+            project: input.project,
+        }),
+        handler: endpoint.handler,
+    });
+}
+function validateMcpNames(registrations, issues) {
+    const names = new Map();
+    for (const registration of registrations) {
+        const existing = names.get(registration.name);
+        if (existing !== undefined && existing.endpoint !== registration.endpoint) {
+            issues.push(`MCP name ${JSON.stringify(registration.name)} is owned by different endpoints`);
+        }
+        else {
+            names.set(registration.name, registration);
+        }
     }
-    return compilation.bindings;
 }
 function formatMcpParameterBindingIssue(entryName, issue) {
     switch (issue.kind) {
         case PARAMETER_BINDING_ISSUE_KIND.duplicate:
-            return `${entryName}: duplicate MCP binding for parameter ${issue.parameterName}`;
+            return `${entryName}: duplicate exposed MCP parameter ${issue.parameterName}`;
+        case PARAMETER_BINDING_ISSUE_KIND.duplicateExclusion:
+            return `${entryName}: duplicate MCP exclusion for parameter ${issue.parameterName}`;
+        case PARAMETER_BINDING_ISSUE_KIND.nonexistentExclusion:
+            return `${entryName}: MCP excludes nonexistent parameter ${issue.parameterName}`;
         case PARAMETER_BINDING_ISSUE_KIND.nonexistent:
-            return `${entryName}: MCP binding names nonexistent parameter ${issue.parameterName}`;
+            return `${entryName}: MCP exposes nonexistent parameter ${issue.parameterName}`;
         case PARAMETER_BINDING_ISSUE_KIND.requiredUnreachable:
             return `${entryName}: required parameter ${issue.parameterName} is unreachable from MCP`;
     }
@@ -69,16 +101,6 @@ function formatMcpParameterBindingIssue(entryName, issue) {
 function isMcpBinding(value) {
     return isChannelPayload(PAYLOAD_KIND.mcpBinding, value);
 }
-export function createMcpOutputSchema(endpoint) {
-    resolveMcpBindings(endpoint);
-    const schema = requireEntryOutput(endpoint.entry).schema;
-    const normalized = schema.type === ZOD_SCHEMA_TYPE.readonly ? unwrapZodSchema(schema) : schema;
-    if (normalized.type !== ZOD_SCHEMA_TYPE.object) {
-        throw new Error(`Entry ${endpoint.entry.name} output contract must use a Zod object schema`);
-    }
-    return normalized;
-}
-function unwrapZodSchema(schema) {
-    const wrapper = schema;
-    return wrapper.unwrap();
+function isMcpChannelBinding(binding) {
+    return binding.channel === CHANNEL.mcp && isMcpBinding(binding.binding);
 }