@alpacakit/channels 0.1.0-beta.19

package/dist/model.js

@@ -0,0 +1,22 @@
+import { PARAMETER_REQUIREMENT_KIND, } from "./values.js";
+export function defineParameter(parameter) {
+    return parameter;
+}
+export function defineEntry(entry) {
+    if (entry.output === undefined) {
+        return { ...entry, output: null };
+    }
+    return { ...entry, output: entry.output };
+}
+export function required() {
+    return { kind: PARAMETER_REQUIREMENT_KIND.required };
+}
+export function optional(input) {
+    if (input === undefined) {
+        return { kind: PARAMETER_REQUIREMENT_KIND.optional };
+    }
+    return {
+        kind: PARAMETER_REQUIREMENT_KIND.optionalWithDefault,
+        defaultValue: input.default,
+    };
+}

package/dist/runtime.d.ts

@@ -0,0 +1,47 @@
+import type { ErasedEntryDefinition, ErasedParameterDefinition, ParameterSet, ParameterValues, RawValueMap } from "./model.js";
+import { ENTRY_DECODE_RESULT_KIND, ENTRY_INPUT_TARGET_KIND } from "./values.js";
+export type EntryInputTarget = {
+    readonly kind: typeof ENTRY_INPUT_TARGET_KIND.entry;
+} | {
+    readonly kind: typeof ENTRY_INPUT_TARGET_KIND.parameter;
+    readonly parameterName: string;
+};
+export declare class EntryInputError extends Error {
+    readonly issues: readonly string[];
+    readonly target: EntryInputTarget;
+    constructor(issues: readonly string[], target?: EntryInputTarget);
+}
+export type EntryDecodeResult<Projection> = {
+    readonly kind: typeof ENTRY_DECODE_RESULT_KIND.resolved;
+    readonly projection: Projection;
+} | {
+    readonly kind: typeof ENTRY_DECODE_RESULT_KIND.invalidInput;
+    readonly issues: readonly string[];
+} | InvalidParameterDecodeResult | {
+    readonly kind: typeof ENTRY_DECODE_RESULT_KIND.internalError;
+    readonly error: unknown;
+};
+type InvalidParameterDecodeResult = {
+    readonly kind: typeof ENTRY_DECODE_RESULT_KIND.invalidParameter;
+    readonly parameterName: string;
+    readonly issues: readonly string[];
+};
+export type ParameterDecodeResult<Parameters extends ParameterSet> = {
+    readonly kind: typeof ENTRY_DECODE_RESULT_KIND.resolved;
+    readonly values: ParameterValues<Parameters>;
+} | InvalidParameterDecodeResult;
+export type RawValueCoercer = (parameter: ErasedParameterDefinition, rawValue: unknown) => unknown;
+export declare function decodeParameterValues<const Parameters extends ParameterSet>(input: {
+    readonly parameters: Parameters;
+    readonly parameterNames: readonly string[];
+    readonly raw: RawValueMap;
+    readonly coerce?: RawValueCoercer;
+}): ParameterDecodeResult<Parameters>;
+export declare function decodeEntryInput<const Entry extends ErasedEntryDefinition>(input: {
+    readonly entry: Entry;
+    readonly parameterNames: readonly string[];
+    readonly raw: RawValueMap;
+    readonly coerce?: RawValueCoercer;
+}): EntryDecodeResult<ReturnType<Entry["project"]>>;
+export {};
+//# sourceMappingURL=runtime.d.ts.map

package/dist/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,qBAAqB,EACrB,yBAAyB,EACzB,YAAY,EACZ,eAAe,EACf,WAAW,EACZ,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,wBAAwB,EACxB,uBAAuB,EAExB,MAAM,aAAa,CAAC;AAErB,MAAM,MAAM,gBAAgB,GACxB;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,uBAAuB,CAAC,KAAK,CAAA;CAAE,GACvD;IACE,QAAQ,CAAC,IAAI,EAAE,OAAO,uBAAuB,CAAC,SAAS,CAAC;IACxD,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC,CAAC;AAMN,qBAAa,eAAgB,SAAQ,KAAK;IAEtC,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE;IAClC,QAAQ,CAAC,MAAM,EAAE,gBAAgB;gBADxB,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,MAAM,GAAE,gBAAqC;CAKzD;AAED,MAAM,MAAM,iBAAiB,CAAC,UAAU,IACpC;IACE,QAAQ,CAAC,IAAI,EAAE,OAAO,wBAAwB,CAAC,QAAQ,CAAC;IACxD,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;CACjC,GACD;IACE,QAAQ,CAAC,IAAI,EAAE,OAAO,wBAAwB,CAAC,YAAY,CAAC;IAC5D,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;CACpC,GACD,4BAA4B,GAC5B;IACE,QAAQ,CAAC,IAAI,EAAE,OAAO,wBAAwB,CAAC,aAAa,CAAC;IAC7D,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACzB,CAAC;AAEN,KAAK,4BAA4B,GAAG;IAClC,QAAQ,CAAC,IAAI,EAAE,OAAO,wBAAwB,CAAC,gBAAgB,CAAC;IAChE,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;CACpC,CAAC;AAEF,MAAM,MAAM,qBAAqB,CAAC,UAAU,SAAS,YAAY,IAC7D;IACE,QAAQ,CAAC,IAAI,EAAE,OAAO,wBAAwB,CAAC,QAAQ,CAAC;IACxD,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC,UAAU,CAAC,CAAC;CAC9C,GACD,4BAA4B,CAAC;AAEjC,MAAM,MAAM,eAAe,GAAG,CAC5B,SAAS,EAAE,yBAAyB,EACpC,QAAQ,EAAE,OAAO,KACd,OAAO,CAAC;AAwBb,wBAAgB,qBAAqB,CACnC,KAAK,CAAC,UAAU,SAAS,YAAY,EACrC,KAAK,EAAE;IACP,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAChC,QAAQ,CAAC,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAC;IAC1B,QAAQ,CAAC,MAAM,CAAC,EAAE,eAAe,CAAC;CACnC,GAAG,qBAAqB,CAAC,UAAU,CAAC,CAgDpC;AAyBD,wBAAgB,gBAAgB,CAC9B,KAAK,CAAC,KAAK,SAAS,qBAAqB,EACzC,KAAK,EAAE;IACP,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,QAAQ,CAAC,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAC;IAC1B,QAAQ,CAAC,MAAM,CAAC,EAAE,eAAe,CAAC;CACnC,GAAG,iBAAiB,CAAC,UAAU,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,CA8ClD"}

package/dist/runtime.js

@@ -0,0 +1,140 @@
+import { CODEC_DECODE_RESULT_KIND } from "@alpacakit/core";
+import { findParameter } from "./internal.js";
+import { ENTRY_DECODE_RESULT_KIND, ENTRY_INPUT_TARGET_KIND, PARAMETER_REQUIREMENT_KIND, } from "./values.js";
+const ENTRY_INPUT_TARGET = {
+    kind: ENTRY_INPUT_TARGET_KIND.entry,
+};
+export class EntryInputError extends Error {
+    issues;
+    target;
+    constructor(issues, target = ENTRY_INPUT_TARGET) {
+        super(issues.join("; "));
+        this.issues = issues;
+        this.target = target;
+        this.name = EntryInputError.name;
+    }
+}
+const PARAMETER_CANDIDATE_KIND = {
+    omitted: "omitted",
+    raw: "raw",
+    default: "default",
+    invalid: "invalid",
+};
+export function decodeParameterValues(input) {
+    const output = new Map();
+    const boundParameterNames = new Set(input.parameterNames);
+    for (const parameterName of input.parameterNames) {
+        const parameter = findParameter(input.parameters, parameterName);
+        if (parameter === null) {
+            return invalidParameter(parameterName, [
+                `Unknown parameter binding: ${parameterName}`,
+            ]);
+        }
+    }
+    for (const parameter of input.parameters) {
+        const candidate = resolveParameterCandidate(parameter, boundParameterNames.has(parameter.name)
+            ? input.raw[parameter.name]
+            : undefined);
+        if (candidate.kind === PARAMETER_CANDIDATE_KIND.omitted) {
+            continue;
+        }
+        if (candidate.kind === PARAMETER_CANDIDATE_KIND.invalid) {
+            return invalidParameter(parameter.name, candidate.issues);
+        }
+        let value;
+        try {
+            value =
+                candidate.kind === PARAMETER_CANDIDATE_KIND.raw && input.coerce
+                    ? input.coerce(parameter, candidate.value)
+                    : candidate.value;
+        }
+        catch (error) {
+            return invalidParameter(parameter.name, [errorMessage(error)]);
+        }
+        try {
+            const decoded = parameter.codec.decode(value);
+            if (decoded.kind === CODEC_DECODE_RESULT_KIND.invalid) {
+                return invalidParameter(parameter.name, decoded.issues);
+            }
+            output.set(parameter.name, decoded.value);
+        }
+        catch (error) {
+            return invalidParameter(parameter.name, [errorMessage(error)]);
+        }
+    }
+    return {
+        kind: ENTRY_DECODE_RESULT_KIND.resolved,
+        values: Object.fromEntries(output),
+    };
+}
+function resolveParameterCandidate(parameter, rawValue) {
+    if (rawValue !== undefined) {
+        return { kind: PARAMETER_CANDIDATE_KIND.raw, value: rawValue };
+    }
+    switch (parameter.requirement.kind) {
+        case PARAMETER_REQUIREMENT_KIND.required:
+            return {
+                kind: PARAMETER_CANDIDATE_KIND.invalid,
+                issues: [`Missing required parameter ${parameter.name}`],
+            };
+        case PARAMETER_REQUIREMENT_KIND.optional:
+            return { kind: PARAMETER_CANDIDATE_KIND.omitted };
+        case PARAMETER_REQUIREMENT_KIND.optionalWithDefault:
+            return {
+                kind: PARAMETER_CANDIDATE_KIND.default,
+                value: parameter.requirement.defaultValue,
+            };
+    }
+}
+export function decodeEntryInput(input) {
+    const decoded = decodeParameterValues({
+        parameters: input.entry.parameters,
+        parameterNames: input.parameterNames,
+        raw: input.raw,
+        ...(input.coerce ? { coerce: input.coerce } : {}),
+    });
+    if (decoded.kind === ENTRY_DECODE_RESULT_KIND.invalidParameter) {
+        return decoded;
+    }
+    const project = input.entry.project;
+    try {
+        return {
+            kind: ENTRY_DECODE_RESULT_KIND.resolved,
+            projection: project({
+                values: decoded.values,
+            }),
+        };
+    }
+    catch (error) {
+        if (error instanceof EntryInputError) {
+            const target = error.target;
+            switch (target.kind) {
+                case ENTRY_INPUT_TARGET_KIND.entry:
+                    return {
+                        kind: ENTRY_DECODE_RESULT_KIND.invalidInput,
+                        issues: error.issues,
+                    };
+                case ENTRY_INPUT_TARGET_KIND.parameter:
+                    if (!input.entry.parameters.some((parameter) => parameter.name === target.parameterName)) {
+                        return { kind: ENTRY_DECODE_RESULT_KIND.internalError, error };
+                    }
+                    return {
+                        kind: ENTRY_DECODE_RESULT_KIND.invalidParameter,
+                        parameterName: target.parameterName,
+                        issues: error.issues,
+                    };
+            }
+        }
+        return { kind: ENTRY_DECODE_RESULT_KIND.internalError, error };
+    }
+}
+function invalidParameter(parameterName, issues) {
+    return {
+        kind: ENTRY_DECODE_RESULT_KIND.invalidParameter,
+        parameterName,
+        issues,
+    };
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/schema.d.ts

@@ -0,0 +1,14 @@
+import type { EntryChannelBinding, EntryTreeDefinition, EntryTreeEndpoint, EntryTreeNode } from "./model.js";
+export declare class EntryTreeDefinitionError extends Error {
+    readonly issues: readonly string[];
+    constructor(issues: readonly string[]);
+}
+export interface EntryTreeVisitor {
+    visitNode(node: EntryTreeNode, path: readonly string[]): void;
+    visitEndpoint(endpoint: EntryTreeEndpoint, node: EntryTreeNode, path: readonly string[]): void;
+}
+export declare function visitEntryTree(tree: EntryTreeDefinition, visitor: EntryTreeVisitor): void;
+export declare function validateEntryTreeStructure(tree: EntryTreeDefinition): readonly string[];
+export declare function findChannelBinding(endpoint: EntryTreeEndpoint, channel: EntryChannelBinding["channel"]): EntryChannelBinding | null;
+export declare function formatTreePath(path: readonly string[]): string;
+//# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,mBAAmB,EACnB,mBAAmB,EACnB,iBAAiB,EACjB,aAAa,EACd,MAAM,YAAY,CAAC;AAEpB,qBAAa,wBAAyB,SAAQ,KAAK;IACrC,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE;gBAAzB,MAAM,EAAE,SAAS,MAAM,EAAE;CAI/C;AAED,MAAM,WAAW,gBAAgB;IAC/B,SAAS,CAAC,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,CAAC;IAC9D,aAAa,CACX,QAAQ,EAAE,iBAAiB,EAC3B,IAAI,EAAE,aAAa,EACnB,IAAI,EAAE,SAAS,MAAM,EAAE,GACtB,IAAI,CAAC;CACT;AAED,wBAAgB,cAAc,CAC5B,IAAI,EAAE,mBAAmB,EACzB,OAAO,EAAE,gBAAgB,GACxB,IAAI,CAsBN;AAED,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,mBAAmB,GACxB,SAAS,MAAM,EAAE,CAyCnB;AAED,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,iBAAiB,EAC3B,OAAO,EAAE,mBAAmB,CAAC,SAAS,CAAC,GACtC,mBAAmB,GAAG,IAAI,CAI5B;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAE9D"}

package/dist/schema.js

@@ -0,0 +1,70 @@
+export class EntryTreeDefinitionError extends Error {
+    issues;
+    constructor(issues) {
+        super(`Invalid entry tree definition:\n${issues.join("\n")}`);
+        this.issues = issues;
+        this.name = EntryTreeDefinitionError.name;
+    }
+}
+export function visitEntryTree(tree, visitor) {
+    const stack = [{ node: tree.root, path: [] }];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (!current) {
+            continue;
+        }
+        const path = [...current.path, current.node.name];
+        visitor.visitNode(current.node, path);
+        for (const endpoint of current.node.endpoints) {
+            visitor.visitEndpoint(endpoint, current.node, path);
+        }
+        for (let index = current.node.children.length - 1; index >= 0; index -= 1) {
+            const child = current.node.children[index];
+            if (child) {
+                stack.push({ node: child, path });
+            }
+        }
+    }
+}
+export function validateEntryTreeStructure(tree) {
+    const issues = [];
+    visitEntryTree(tree, {
+        visitNode(node, path) {
+            const location = formatTreePath(path);
+            if (node.name.length === 0) {
+                issues.push(`${location}: node name must not be empty`);
+            }
+            const childNames = new Set();
+            for (const child of node.children) {
+                if (childNames.has(child.name)) {
+                    issues.push(`${location}: duplicate child name ${JSON.stringify(child.name)}`);
+                }
+                childNames.add(child.name);
+            }
+            const overrideChannels = new Set();
+            for (const override of node.segments) {
+                if (overrideChannels.has(override.channel)) {
+                    issues.push(`${location}: duplicate ${override.channel} segment override`);
+                }
+                overrideChannels.add(override.channel);
+            }
+        },
+        visitEndpoint(endpoint, _node, path) {
+            const location = `${formatTreePath(path)}#${endpoint.entry.name}`;
+            const channels = new Set();
+            for (const channelBinding of endpoint.channels) {
+                if (channels.has(channelBinding.channel)) {
+                    issues.push(`${location}: duplicate ${channelBinding.channel} channel binding`);
+                }
+                channels.add(channelBinding.channel);
+            }
+        },
+    });
+    return issues;
+}
+export function findChannelBinding(endpoint, channel) {
+    return (endpoint.channels.find((candidate) => candidate.channel === channel) ?? null);
+}
+export function formatTreePath(path) {
+    return path.map((segment) => segment || "<empty>").join("/");
+}

package/dist/tree-internal.d.ts

@@ -0,0 +1,14 @@
+import type { ChannelSegmentOverride, EntryChannelBinding } from "./model.js";
+import type { Channel } from "./values.js";
+export declare const PAYLOAD_KIND: {
+    readonly cliBinding: "cli_binding";
+    readonly cliSegment: "cli_segment";
+    readonly mcpBinding: "mcp_binding";
+};
+type PayloadKind = (typeof PAYLOAD_KIND)[keyof typeof PAYLOAD_KIND];
+export declare function registerChannelPayload(kind: PayloadKind, payload: object): void;
+export declare function isChannelPayload(kind: PayloadKind, value: unknown): boolean;
+export declare function createChannelSegmentOverride(channel: Channel, segment: unknown): ChannelSegmentOverride;
+export declare function createEntryChannelBinding<const ChannelName extends Channel, const ParameterName extends string>(channel: ChannelName, binding: unknown): EntryChannelBinding<ChannelName, ParameterName>;
+export {};
+//# sourceMappingURL=tree-internal.d.ts.map

package/dist/tree-internal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree-internal.d.ts","sourceRoot":"","sources":["../src/tree-internal.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAC9E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,eAAO,MAAM,YAAY;;;;CAIf,CAAC;AAEX,KAAK,WAAW,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,OAAO,YAAY,CAAC,CAAC;AAIpE,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,WAAW,EACjB,OAAO,EAAE,MAAM,GACd,IAAI,CAEN;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAM3E;AAED,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,OAAO,GACf,sBAAsB,CAExB;AAED,wBAAgB,yBAAyB,CACvC,KAAK,CAAC,WAAW,SAAS,OAAO,EACjC,KAAK,CAAC,aAAa,SAAS,MAAM,EAElC,OAAO,EAAE,WAAW,EACpB,OAAO,EAAE,OAAO,GACf,mBAAmB,CAAC,WAAW,EAAE,aAAa,CAAC,CAKjD"}

package/dist/tree-internal.js

@@ -0,0 +1,20 @@
+export const PAYLOAD_KIND = {
+    cliBinding: "cli_binding",
+    cliSegment: "cli_segment",
+    mcpBinding: "mcp_binding",
+};
+const REGISTERED_PAYLOADS = new WeakMap();
+export function registerChannelPayload(kind, payload) {
+    REGISTERED_PAYLOADS.set(payload, kind);
+}
+export function isChannelPayload(kind, value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        REGISTERED_PAYLOADS.get(value) === kind);
+}
+export function createChannelSegmentOverride(channel, segment) {
+    return { channel, segment };
+}
+export function createEntryChannelBinding(channel, binding) {
+    return { channel, binding };
+}

package/dist/values.d.ts

@@ -0,0 +1,32 @@
+export declare const CHANNEL: {
+    readonly cli: "cli";
+    readonly mcp: "mcp";
+};
+export type Channel = (typeof CHANNEL)[keyof typeof CHANNEL];
+export declare const PARAMETER_REQUIREMENT_KIND: {
+    readonly required: "required";
+    readonly optional: "optional";
+    readonly optionalWithDefault: "optional_with_default";
+};
+export declare const VALUE_SHAPE_KIND: {
+    readonly string: "string";
+    readonly boolean: "boolean";
+    readonly positiveInteger: "positive_integer";
+    readonly stringEnum: "string_enum";
+    readonly array: "array";
+};
+export declare const ENTRY_DECODE_RESULT_KIND: {
+    readonly resolved: "resolved";
+    readonly invalidInput: "invalid_input";
+    readonly invalidParameter: "invalid_parameter";
+    readonly internalError: "internal_error";
+};
+export declare const ENTRY_INPUT_TARGET_KIND: {
+    readonly entry: "entry";
+    readonly parameter: "parameter";
+};
+export declare const ENTRY_OUTPUT_DESCRIPTION_KIND: {
+    readonly typed: "typed";
+    readonly none: "none";
+};
+//# sourceMappingURL=values.d.ts.map

package/dist/values.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"values.d.ts","sourceRoot":"","sources":["../src/values.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,OAAO;;;CAGV,CAAC;AAEX,MAAM,MAAM,OAAO,GAAG,CAAC,OAAO,OAAO,CAAC,CAAC,MAAM,OAAO,OAAO,CAAC,CAAC;AAE7D,eAAO,MAAM,0BAA0B;;;;CAI7B,CAAC;AAEX,eAAO,MAAM,gBAAgB;;;;;;CAMnB,CAAC;AAEX,eAAO,MAAM,wBAAwB;;;;;CAK3B,CAAC;AAEX,eAAO,MAAM,uBAAuB;;;CAG1B,CAAC;AAEX,eAAO,MAAM,6BAA6B;;;CAGhC,CAAC"}

package/dist/values.js

@@ -0,0 +1,30 @@
+export const CHANNEL = {
+    cli: "cli",
+    mcp: "mcp",
+};
+export const PARAMETER_REQUIREMENT_KIND = {
+    required: "required",
+    optional: "optional",
+    optionalWithDefault: "optional_with_default",
+};
+export const VALUE_SHAPE_KIND = {
+    string: "string",
+    boolean: "boolean",
+    positiveInteger: "positive_integer",
+    stringEnum: "string_enum",
+    array: "array",
+};
+export const ENTRY_DECODE_RESULT_KIND = {
+    resolved: "resolved",
+    invalidInput: "invalid_input",
+    invalidParameter: "invalid_parameter",
+    internalError: "internal_error",
+};
+export const ENTRY_INPUT_TARGET_KIND = {
+    entry: "entry",
+    parameter: "parameter",
+};
+export const ENTRY_OUTPUT_DESCRIPTION_KIND = {
+    typed: "typed",
+    none: "none",
+};

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@alpacakit/channels",
+  "version": "0.1.0-beta.19",
+  "description": "Neutral multi-channel entry definitions with CLI and MCP binding adapters.",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./cli": {
+      "types": "./dist/cli.d.ts",
+      "import": "./dist/cli.js"
+    },
+    "./mcp": {
+      "types": "./dist/mcp.d.ts",
+      "import": "./dist/mcp.js"
+    }
+  },
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "README*.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@alpacakit/core": "0.1.0-beta.19"
+  },
+  "peerDependencies": {
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18",
+    "zod": "4.3.6"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run"
+  }
+}