@alpacakit/channels 0.1.0-beta.19

package/dist/cli-tree.js

@@ -0,0 +1,421 @@
+import { coerceCliArgvValue } from "./cli-coercion.js";
+import { CLI_OPTION_ACTION_KIND, compileCliBinding, } from "./cli-compiler.js";
+import { createCliHelpSurface, validateCliCommandHelp, validateCliHelpExamples, } from "./cli-help-projection.js";
+import { CLI_ROUTER_RESULT_KIND, } from "./cli-model.js";
+import { isCliEntryBinding, isCliSegment } from "./cli-schema.js";
+import { CLI_OPTION_VALUE_MODE, CLI_POSITIONAL_PLAN_KIND, } from "./cli-values.js";
+import { decodeEntryInput } from "./runtime.js";
+import { EntryTreeDefinitionError, findChannelBinding, formatTreePath, validateEntryTreeStructure, visitEntryTree, } from "./schema.js";
+import { CHANNEL, ENTRY_DECODE_RESULT_KIND } from "./values.js";
+const CLI_ARGUMENT_SYNTAX = {
+    inlineValueSeparator: "=",
+    optionPrefix: "-",
+    positionalSeparator: "--",
+    repeatedValueSeparator: ",",
+};
+const CLI_ARGUMENT_TOKEN_KIND = {
+    option: "option",
+    positionalSeparator: "positional_separator",
+    value: "value",
+};
+const CLI_PARSE_RESULT_KIND = {
+    parsed: "parsed",
+    raw: "raw",
+};
+const CLI_SEGMENT_NAME_KIND = {
+    alias: "alias",
+    token: "token",
+};
+const CLI_TREE_VALIDATION_ISSUE = {
+    subcommandHintWithoutChildren: "CLI subcommand hint requires at least one child command",
+};
+const EMPTY_CLI_GROUP_HELP = {
+    subcommandHint: null,
+    examples: [],
+};
+export function createCliRouter(tree) {
+    const root = compileCliTree(tree);
+    return {
+        help: root.help,
+        endpoints: listCliEndpoints(root),
+        resolve: (argv) => resolveCli(root, argv),
+    };
+}
+function listCliEndpoints(root) {
+    const endpoints = [];
+    const visited = new Set();
+    const pending = [root];
+    while (pending.length > 0) {
+        const node = pending.pop();
+        if (!node || visited.has(node)) {
+            continue;
+        }
+        visited.add(node);
+        if (node.endpoint !== null) {
+            endpoints.push(node.endpoint.endpoint);
+        }
+        pending.push(...node.childByToken.values());
+    }
+    return endpoints;
+}
+function compileCliTree(tree) {
+    const issues = [...validateEntryTreeStructure(tree)];
+    const nodeRecords = new Map();
+    visitEntryTree(tree, {
+        visitNode(node, path) {
+            nodeRecords.set(node, {
+                path,
+                segment: cliSegmentFor(node, path, node === tree.root, issues),
+                endpoint: cliEndpointFor(node, path, issues),
+            });
+        },
+        visitEndpoint() { },
+    });
+    const publicNodes = new Map();
+    const pending = [];
+    visitEntryTree(tree, {
+        visitNode(node) {
+            pending.push(node);
+        },
+        visitEndpoint() { },
+    });
+    for (let index = pending.length - 1; index >= 0; index -= 1) {
+        const node = pending[index];
+        if (!node) {
+            continue;
+        }
+        const record = nodeRecords.get(node);
+        if (!record) {
+            continue;
+        }
+        const children = node.children.flatMap((child) => {
+            const compiled = publicNodes.get(child);
+            return compiled ? [compiled] : [];
+        });
+        if (record.segment.help.subcommandHint !== null && children.length === 0) {
+            issues.push(`${formatTreePath(record.path)}: ${CLI_TREE_VALIDATION_ISSUE.subcommandHintWithoutChildren}`);
+        }
+        if (record.endpoint === null &&
+            children.length === 0 &&
+            node !== tree.root) {
+            continue;
+        }
+        validateCliChildren(record.path, children, issues);
+        if (record.endpoint !== null &&
+            record.endpoint.positionals.length > 0 &&
+            children.length > 0) {
+            issues.push(`${formatTreePath(record.path)}: executable CLI node cannot have both positionals and children`);
+        }
+        const childByToken = new Map();
+        for (const child of children) {
+            childByToken.set(child.segment.token, child);
+            for (const alias of child.segment.aliases) {
+                childByToken.set(alias, child);
+            }
+        }
+        const compiledNode = {
+            path: record.path,
+            segment: record.segment,
+            endpoint: record.endpoint,
+            childByToken,
+            help: createCliHelpSurface({
+                node,
+                segment: record.segment,
+                endpoint: record.endpoint,
+                childHelp: children.map((child) => child.help),
+                root: node === tree.root,
+            }),
+        };
+        publicNodes.set(node, compiledNode);
+    }
+    if (issues.length > 0) {
+        throw new EntryTreeDefinitionError(issues);
+    }
+    const root = publicNodes.get(tree.root);
+    if (!root) {
+        throw new EntryTreeDefinitionError([
+            "entry tree has no public CLI endpoint",
+        ]);
+    }
+    return root;
+}
+function cliSegmentFor(node, path, root, issues) {
+    const override = node.segments.find((row) => row.channel === CHANNEL.cli);
+    let segment;
+    if (!override) {
+        segment = { token: node.name, aliases: [], help: EMPTY_CLI_GROUP_HELP };
+    }
+    else if (!isCliSegment(override.segment)) {
+        issues.push(`${formatTreePath(path)}: invalid CLI segment override`);
+        segment = { token: node.name, aliases: [], help: EMPTY_CLI_GROUP_HELP };
+    }
+    else {
+        segment = override.segment;
+    }
+    validateCliHelpExamples(segment.help.examples, formatTreePath(path), issues);
+    if (!root) {
+        validateCliCommandToken(segment.token, CLI_SEGMENT_NAME_KIND.token, path, issues);
+        for (const alias of segment.aliases) {
+            validateCliCommandToken(alias, CLI_SEGMENT_NAME_KIND.alias, path, issues);
+        }
+    }
+    return segment;
+}
+function validateCliCommandToken(token, kind, path, issues) {
+    if (token.length === 0) {
+        issues.push(`${formatTreePath(path)}: CLI segment ${kind} must not be empty`);
+        return;
+    }
+    if (classifyCliArgumentToken(token) !== CLI_ARGUMENT_TOKEN_KIND.value) {
+        issues.push(`${formatTreePath(path)}: CLI segment ${kind} ${JSON.stringify(token)} is unreachable`);
+    }
+}
+function cliEndpointFor(node, path, issues) {
+    const endpoints = node.endpoints.flatMap((endpoint) => findChannelBinding(endpoint, CHANNEL.cli) ? [endpoint] : []);
+    if (endpoints.length > 1) {
+        issues.push(`${formatTreePath(path)}: more than one public CLI endpoint`);
+    }
+    const endpoint = endpoints[0];
+    if (!endpoint) {
+        return null;
+    }
+    const channelBinding = findChannelBinding(endpoint, CHANNEL.cli);
+    if (!channelBinding || !isCliEntryBinding(channelBinding.binding)) {
+        issues.push(`${formatTreePath(path)}: invalid CLI endpoint binding`);
+        return null;
+    }
+    const location = `${formatTreePath(path)}#${endpoint.entry.name}`;
+    const compiled = compileCliBinding(endpoint, channelBinding.binding, location, issues);
+    validateCliCommandHelp(compiled, location, issues);
+    return compiled;
+}
+function validateCliChildren(path, children, issues) {
+    const tokens = new Map();
+    for (const child of children) {
+        for (const token of [child.segment.token, ...child.segment.aliases]) {
+            const owner = tokens.get(token);
+            if (owner !== undefined) {
+                issues.push(`${formatTreePath(path)}: CLI sibling token/alias collision ${JSON.stringify(token)} between ${owner} and ${child.help.name}`);
+            }
+            else {
+                tokens.set(token, child.help.name);
+            }
+        }
+    }
+}
+function resolveCli(root, argv) {
+    let node = root;
+    let index = 0;
+    while (index < argv.length) {
+        const token = argv[index];
+        if (token === undefined) {
+            break;
+        }
+        if (classifyCliArgumentToken(token) !== CLI_ARGUMENT_TOKEN_KIND.value) {
+            break;
+        }
+        const child = node.childByToken.get(token);
+        if (!child) {
+            break;
+        }
+        node = child;
+        index += 1;
+    }
+    const unmatchedToken = argv[index];
+    if (node.endpoint !== null &&
+        node.childByToken.size > 0 &&
+        unmatchedToken !== undefined &&
+        classifyCliArgumentToken(unmatchedToken) === CLI_ARGUMENT_TOKEN_KIND.value) {
+        return {
+            kind: CLI_ROUTER_RESULT_KIND.unknownCommand,
+            path: node.path,
+            token: unmatchedToken,
+        };
+    }
+    if (node.endpoint === null) {
+        return unmatchedToken === undefined
+            ? { kind: CLI_ROUTER_RESULT_KIND.incompleteCommand, path: node.path }
+            : {
+                kind: CLI_ROUTER_RESULT_KIND.unknownCommand,
+                path: node.path,
+                token: unmatchedToken,
+            };
+    }
+    const compiledEndpoint = node.endpoint;
+    const rawResult = parseCliArguments(compiledEndpoint, argv.slice(index));
+    switch (rawResult.kind) {
+        case CLI_ROUTER_RESULT_KIND.invalidInput:
+        case CLI_ROUTER_RESULT_KIND.invalidParameter:
+            return { ...rawResult, path: node.path };
+        case CLI_PARSE_RESULT_KIND.raw:
+            break;
+    }
+    const endpoint = compiledEndpoint.endpoint;
+    const decoded = decodeEntryInput({
+        entry: endpoint.entry,
+        parameterNames: endpoint.entry.parameters.map((parameter) => parameter.name),
+        raw: rawResult.raw,
+        coerce: (parameter, rawValue) => coerceCliArgvValue(parameter.codec.shape, rawValue, cliCoercionFor(compiledEndpoint, parameter.name)),
+    });
+    switch (decoded.kind) {
+        case ENTRY_DECODE_RESULT_KIND.resolved:
+            return {
+                kind: CLI_ROUTER_RESULT_KIND.resolved,
+                path: node.path,
+                endpoint,
+                projection: decoded.projection,
+            };
+        case ENTRY_DECODE_RESULT_KIND.invalidInput:
+            return {
+                kind: CLI_ROUTER_RESULT_KIND.invalidInput,
+                path: node.path,
+                issues: decoded.issues,
+            };
+        case ENTRY_DECODE_RESULT_KIND.invalidParameter:
+            return {
+                kind: CLI_ROUTER_RESULT_KIND.invalidParameter,
+                path: node.path,
+                parameterName: decoded.parameterName,
+                issues: decoded.issues,
+            };
+        case ENTRY_DECODE_RESULT_KIND.internalError:
+            return {
+                kind: CLI_ROUTER_RESULT_KIND.internalError,
+                path: node.path,
+                error: decoded.error,
+            };
+    }
+}
+function cliCoercionFor(endpoint, parameterName) {
+    return ([...endpoint.options, ...endpoint.positionals].find((binding) => binding.parameter.name === parameterName)?.coercion ?? null);
+}
+function parseCliArguments(endpoint, argv) {
+    const raw = new Map();
+    const positionalValues = [];
+    let positionalOnly = false;
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token === undefined) {
+            continue;
+        }
+        if (!positionalOnly) {
+            switch (classifyCliArgumentToken(token)) {
+                case CLI_ARGUMENT_TOKEN_KIND.positionalSeparator:
+                    positionalOnly = true;
+                    continue;
+                case CLI_ARGUMENT_TOKEN_KIND.option: {
+                    const parsed = parseCliOption({ endpoint, argv, index, raw });
+                    switch (parsed.kind) {
+                        case CLI_ROUTER_RESULT_KIND.invalidInput:
+                        case CLI_ROUTER_RESULT_KIND.invalidParameter:
+                            return parsed;
+                        case CLI_PARSE_RESULT_KIND.parsed:
+                            if (parsed.consumedNext) {
+                                index += 1;
+                            }
+                    }
+                    continue;
+                }
+                case CLI_ARGUMENT_TOKEN_KIND.value:
+                    break;
+            }
+        }
+        positionalValues.push(token);
+    }
+    return bindCliPositionals(endpoint, positionalValues, raw);
+}
+function parseCliOption(input) {
+    const token = input.argv[input.index] ?? "";
+    const [flag, inlineValue] = splitOptionToken(token);
+    const action = input.endpoint.optionByToken.get(flag);
+    if (!action) {
+        return invalidCliInput(`Unknown option ${flag}`);
+    }
+    if (action.kind === CLI_OPTION_ACTION_KIND.setBoolean) {
+        return setCliBooleanValue(input.raw, action, flag, inlineValue);
+    }
+    const option = action.option;
+    const value = inlineValue ?? input.argv[input.index + 1];
+    if (value === undefined) {
+        return invalidCliParameter(option.parameter.name, `${flag} requires a value`);
+    }
+    storeOptionValue(input.raw, option, value);
+    return {
+        kind: CLI_PARSE_RESULT_KIND.parsed,
+        consumedNext: inlineValue === undefined,
+    };
+}
+function setCliBooleanValue(raw, action, flag, inlineValue) {
+    if (inlineValue !== undefined) {
+        return invalidCliParameter(action.parameterName, `${flag} does not take a value`);
+    }
+    raw.set(action.parameterName, action.value);
+    return { kind: CLI_PARSE_RESULT_KIND.parsed, consumedNext: false };
+}
+function bindCliPositionals(endpoint, positionalValues, raw) {
+    let positionalIndex = 0;
+    for (const positional of endpoint.positionals) {
+        if (positional.kind === CLI_POSITIONAL_PLAN_KIND.rest) {
+            const values = positionalValues.slice(positionalIndex);
+            if (values.length > 0) {
+                raw.set(positional.parameter.name, values);
+            }
+            positionalIndex = positionalValues.length;
+        }
+        else {
+            const value = positionalValues[positionalIndex];
+            if (value !== undefined) {
+                raw.set(positional.parameter.name, value);
+                positionalIndex += 1;
+            }
+        }
+    }
+    if (positionalIndex < positionalValues.length) {
+        return invalidCliInput(`Unexpected argument ${positionalValues[positionalIndex]}`);
+    }
+    return { kind: CLI_PARSE_RESULT_KIND.raw, raw: Object.fromEntries(raw) };
+}
+function storeOptionValue(raw, option, value) {
+    switch (option.valueMode) {
+        case CLI_OPTION_VALUE_MODE.replace:
+            raw.set(option.parameter.name, value);
+            return;
+        case CLI_OPTION_VALUE_MODE.repeat:
+            appendOptionValues(raw, option.parameter.name, [value]);
+            return;
+        case CLI_OPTION_VALUE_MODE.commaOrRepeat:
+            appendOptionValues(raw, option.parameter.name, value.split(CLI_ARGUMENT_SYNTAX.repeatedValueSeparator));
+            return;
+    }
+}
+function appendOptionValues(raw, parameterName, values) {
+    const current = raw.get(parameterName);
+    raw.set(parameterName, Array.isArray(current) ? [...current, ...values] : values);
+}
+function splitOptionToken(token) {
+    const equalsIndex = token.indexOf(CLI_ARGUMENT_SYNTAX.inlineValueSeparator);
+    return equalsIndex < 0
+        ? [token, undefined]
+        : [token.slice(0, equalsIndex), token.slice(equalsIndex + 1)];
+}
+function classifyCliArgumentToken(token) {
+    if (token === CLI_ARGUMENT_SYNTAX.positionalSeparator) {
+        return CLI_ARGUMENT_TOKEN_KIND.positionalSeparator;
+    }
+    return token.startsWith(CLI_ARGUMENT_SYNTAX.optionPrefix)
+        ? CLI_ARGUMENT_TOKEN_KIND.option
+        : CLI_ARGUMENT_TOKEN_KIND.value;
+}
+function invalidCliInput(issue) {
+    return {
+        kind: CLI_ROUTER_RESULT_KIND.invalidInput,
+        issues: [issue],
+    };
+}
+function invalidCliParameter(parameterName, issue) {
+    return {
+        kind: CLI_ROUTER_RESULT_KIND.invalidParameter,
+        parameterName,
+        issues: [issue],
+    };
+}

package/dist/cli-values.d.ts

@@ -0,0 +1,24 @@
+export declare const CLI_BOOLEAN_MODE: {
+    readonly flag: "flag";
+    readonly value: "value";
+};
+export declare const CLI_HELP_USAGE_KIND: {
+    readonly authored: "authored";
+    readonly derived: "derived";
+};
+export declare const CLI_OPTION_KIND: {
+    readonly booleanFlag: "boolean_flag";
+    readonly value: "value";
+};
+export declare const CLI_OPTION_VALUE_MODE: {
+    readonly replace: "replace";
+    readonly repeat: "repeat";
+    readonly commaOrRepeat: "comma_or_repeat";
+};
+export declare const CLI_POSITIONAL_PLAN_KIND: {
+    readonly single: "single";
+    readonly rest: "rest";
+};
+export declare function defaultCliOptionFlag(parameterName: string): `--${string}`;
+export declare function defaultCliValueName(parameterName: string): string;
+//# sourceMappingURL=cli-values.d.ts.map

package/dist/cli-values.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-values.d.ts","sourceRoot":"","sources":["../src/cli-values.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,gBAAgB;;;CAGnB,CAAC;AAEX,eAAO,MAAM,mBAAmB;;;CAGtB,CAAC;AAEX,eAAO,MAAM,eAAe;;;CAGlB,CAAC;AAEX,eAAO,MAAM,qBAAqB;;;;CAIxB,CAAC;AAEX,eAAO,MAAM,wBAAwB;;;CAG3B,CAAC;AAEX,wBAAgB,oBAAoB,CAAC,aAAa,EAAE,MAAM,GAAG,KAAK,MAAM,EAAE,CAEzE;AAED,wBAAgB,mBAAmB,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAIjE"}

package/dist/cli-values.js

@@ -0,0 +1,40 @@
+const CLI_PARAMETER_SYNTAX = {
+    longOptionPrefix: "--",
+    parameterWordSeparator: "-",
+    valueWordSeparator: "_",
+};
+export const CLI_BOOLEAN_MODE = {
+    flag: "flag",
+    value: "value",
+};
+export const CLI_HELP_USAGE_KIND = {
+    authored: "authored",
+    derived: "derived",
+};
+export const CLI_OPTION_KIND = {
+    booleanFlag: "boolean_flag",
+    value: "value",
+};
+export const CLI_OPTION_VALUE_MODE = {
+    replace: "replace",
+    repeat: "repeat",
+    commaOrRepeat: "comma_or_repeat",
+};
+export const CLI_POSITIONAL_PLAN_KIND = {
+    single: "single",
+    rest: "rest",
+};
+export function defaultCliOptionFlag(parameterName) {
+    return `${CLI_PARAMETER_SYNTAX.longOptionPrefix}${toKebabCase(parameterName)}`;
+}
+export function defaultCliValueName(parameterName) {
+    return toKebabCase(parameterName)
+        .replace(/-/g, CLI_PARAMETER_SYNTAX.valueWordSeparator)
+        .toUpperCase();
+}
+function toKebabCase(name) {
+    return name
+        .replace(/[A-Z]/g, (letter) => `${CLI_PARAMETER_SYNTAX.parameterWordSeparator}${letter.toLowerCase()}`)
+        .replace(/_/g, CLI_PARAMETER_SYNTAX.parameterWordSeparator)
+        .replace(/^-/, "");
+}

package/dist/cli.d.ts

@@ -0,0 +1,6 @@
+export * from "./cli-executor.js";
+export * from "./cli-model.js";
+export * from "./cli-presentation.js";
+export { createCliRouter } from "./cli-tree.js";
+export { CLI_BOOLEAN_MODE, CLI_HELP_USAGE_KIND, CLI_OPTION_KIND, CLI_OPTION_VALUE_MODE, } from "./cli-values.js";
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,uBAAuB,CAAC;AACtC,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EACL,gBAAgB,EAChB,mBAAmB,EACnB,eAAe,EACf,qBAAqB,GACtB,MAAM,iBAAiB,CAAC"}

package/dist/cli.js

@@ -0,0 +1,5 @@
+export * from "./cli-executor.js";
+export * from "./cli-model.js";
+export * from "./cli-presentation.js";
+export { createCliRouter } from "./cli-tree.js";
+export { CLI_BOOLEAN_MODE, CLI_HELP_USAGE_KIND, CLI_OPTION_KIND, CLI_OPTION_VALUE_MODE, } from "./cli-values.js";

package/dist/codecs.d.ts

@@ -0,0 +1,25 @@
+import { z } from "zod";
+import type { ValueCodec, ValueForShape, ValueShape } from "./model.js";
+declare function defineValueCodec<const Shape extends ValueShape>(input: {
+    readonly schema: z.ZodType<ValueForShape<Shape>>;
+    readonly shape: Shape;
+}): ValueCodec<ValueForShape<Shape>>;
+declare function stringCodec(): ValueCodec<string>;
+declare function booleanCodec(): ValueCodec<boolean>;
+declare function positiveIntegerCodec(input?: {
+    readonly max: number | null;
+}): ValueCodec<number>;
+declare function stringEnumCodec<const Values extends readonly [string, ...string[]]>(values: Values): ValueCodec<Values[number]>;
+declare function stringEnumListCodec<const Values extends readonly [string, ...string[]]>(values: Values): ValueCodec<readonly Values[number][]>;
+declare function stringListCodec(): ValueCodec<readonly string[]>;
+export declare const codecs: {
+    define: typeof defineValueCodec;
+    string: typeof stringCodec;
+    stringList: typeof stringListCodec;
+    boolean: typeof booleanCodec;
+    positiveInteger: typeof positiveIntegerCodec;
+    stringEnum: typeof stringEnumCodec;
+    stringEnumList: typeof stringEnumListCodec;
+};
+export {};
+//# sourceMappingURL=codecs.d.ts.map

package/dist/codecs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codecs.d.ts","sourceRoot":"","sources":["../src/codecs.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAGxE,iBAAS,gBAAgB,CAAC,KAAK,CAAC,KAAK,SAAS,UAAU,EAAE,KAAK,EAAE;IAC/D,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC;IACjD,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;CACvB,GAAG,UAAU,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,CAQnC;AAED,iBAAS,WAAW,IAAI,UAAU,CAAC,MAAM,CAAC,CAKzC;AAED,iBAAS,YAAY,IAAI,UAAU,CAAC,OAAO,CAAC,CAK3C;AAED,iBAAS,oBAAoB,CAC3B,KAAK,GAAE;IAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;CAAkB,GACrD,UAAU,CAAC,MAAM,CAAC,CAQpB;AAED,iBAAS,eAAe,CAAC,KAAK,CAAC,MAAM,SAAS,SAAS,CAAC,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC,EAC1E,MAAM,EAAE,MAAM,GACb,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAQ5B;AAED,iBAAS,mBAAmB,CAC1B,KAAK,CAAC,MAAM,SAAS,SAAS,CAAC,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC,EACnD,MAAM,EAAE,MAAM,GAAG,UAAU,CAAC,SAAS,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,CAYvD;AAED,iBAAS,eAAe,IAAI,UAAU,CAAC,SAAS,MAAM,EAAE,CAAC,CASxD;AAED,eAAO,MAAM,MAAM;;;;;;;;CAQlB,CAAC"}

package/dist/codecs.js

@@ -0,0 +1,74 @@
+import { createSchemaRuntimeCodec, readonlyArraySchema } from "@alpacakit/core";
+import { z } from "zod";
+import { VALUE_SHAPE_KIND } from "./values.js";
+function defineValueCodec(input) {
+    const codec = createSchemaRuntimeCodec(input.schema);
+    return {
+        schema: input.schema,
+        shape: input.shape,
+        decode: codec.decode,
+        encode: codec.encode,
+    };
+}
+function stringCodec() {
+    return defineValueCodec({
+        schema: z.string(),
+        shape: { kind: VALUE_SHAPE_KIND.string },
+    });
+}
+function booleanCodec() {
+    return defineValueCodec({
+        schema: z.boolean(),
+        shape: { kind: VALUE_SHAPE_KIND.boolean },
+    });
+}
+function positiveIntegerCodec(input = { max: null }) {
+    const base = z.number().int().positive();
+    return defineValueCodec({
+        schema: (input.max === null
+            ? base
+            : base.max(input.max)),
+        shape: { kind: VALUE_SHAPE_KIND.positiveInteger },
+    });
+}
+function stringEnumCodec(values) {
+    return defineValueCodec({
+        schema: z.enum(values),
+        shape: {
+            kind: VALUE_SHAPE_KIND.stringEnum,
+            values,
+        },
+    });
+}
+function stringEnumListCodec(values) {
+    const element = stringEnumCodec(values);
+    return defineValueCodec({
+        schema: readonlyArraySchema(element.schema),
+        shape: {
+            kind: VALUE_SHAPE_KIND.array,
+            element: {
+                kind: VALUE_SHAPE_KIND.stringEnum,
+                values,
+            },
+        },
+    });
+}
+function stringListCodec() {
+    const element = stringCodec();
+    return defineValueCodec({
+        schema: readonlyArraySchema(element.schema),
+        shape: {
+            kind: VALUE_SHAPE_KIND.array,
+            element: element.shape,
+        },
+    });
+}
+export const codecs = {
+    define: defineValueCodec,
+    string: stringCodec,
+    stringList: stringListCodec,
+    boolean: booleanCodec,
+    positiveInteger: positiveIntegerCodec,
+    stringEnum: stringEnumCodec,
+    stringEnumList: stringEnumListCodec,
+};

package/dist/contract.d.ts

@@ -0,0 +1,12 @@
+import { type JsonValue } from "@alpacakit/core";
+import type { z } from "zod";
+import type { EntryDefinition, EntryDefinitionWithOutput, OutputContract, ParameterSet } from "./model.js";
+export declare function createOutputContract<Value extends JsonValue>(schema: z.ZodType<Value>): OutputContract<Value>;
+export declare class EntryOutputContractError extends Error {
+    readonly entryName: string;
+    readonly issues: readonly string[];
+    constructor(entryName: string, issues: readonly string[]);
+}
+export declare function requireEntryOutput<const Name extends string, const Parameters extends ParameterSet, Projection, Output extends JsonValue>(entry: EntryDefinition<Name, Parameters, Projection, Output>): OutputContract<Output>;
+export declare function verifyEntryOutput<const Name extends string, const Parameters extends ParameterSet, Projection, Output extends JsonValue>(entry: EntryDefinitionWithOutput<Name, Parameters, Projection, Output>, value: NoInfer<Output>): Output;
+//# sourceMappingURL=contract.d.ts.map

package/dist/contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../src/contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,SAAS,EACf,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,KAAK,EACV,eAAe,EACf,yBAAyB,EACzB,cAAc,EACd,YAAY,EACb,MAAM,YAAY,CAAC;AAEpB,wBAAgB,oBAAoB,CAAC,KAAK,SAAS,SAAS,EAC1D,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,GACvB,cAAc,CAAC,KAAK,CAAC,CAGvB;AAED,qBAAa,wBAAyB,SAAQ,KAAK;IAE/C,QAAQ,CAAC,SAAS,EAAE,MAAM;IAC1B,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE;gBADzB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,SAAS,MAAM,EAAE;CAKrC;AAED,wBAAgB,kBAAkB,CAChC,KAAK,CAAC,IAAI,SAAS,MAAM,EACzB,KAAK,CAAC,UAAU,SAAS,YAAY,EACrC,UAAU,EACV,MAAM,SAAS,SAAS,EAExB,KAAK,EAAE,eAAe,CAAC,IAAI,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,CAAC,GAC3D,cAAc,CAAC,MAAM,CAAC,CAKxB;AAED,wBAAgB,iBAAiB,CAC/B,KAAK,CAAC,IAAI,SAAS,MAAM,EACzB,KAAK,CAAC,UAAU,SAAS,YAAY,EACrC,UAAU,EACV,MAAM,SAAS,SAAS,EAExB,KAAK,EAAE,yBAAyB,CAAC,IAAI,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,CAAC,EACtE,KAAK,EAAE,OAAO,CAAC,MAAM,CAAC,GACrB,MAAM,CAMR"}

package/dist/contract.js

@@ -0,0 +1,28 @@
+import { CODEC_DECODE_RESULT_KIND, createSchemaRuntimeCodec, } from "@alpacakit/core";
+export function createOutputContract(schema) {
+    const { decode } = createSchemaRuntimeCodec(schema);
+    return { schema, decode };
+}
+export class EntryOutputContractError extends Error {
+    entryName;
+    issues;
+    constructor(entryName, issues) {
+        super(`Invalid output for entry ${entryName}:\n${issues.join("\n")}`);
+        this.entryName = entryName;
+        this.issues = issues;
+        this.name = EntryOutputContractError.name;
+    }
+}
+export function requireEntryOutput(entry) {
+    if (entry.output === null) {
+        throw new Error(`Entry ${entry.name} does not declare an output contract`);
+    }
+    return entry.output;
+}
+export function verifyEntryOutput(entry, value) {
+    const decoded = requireEntryOutput(entry).decode(value);
+    if (decoded.kind === CODEC_DECODE_RESULT_KIND.invalid) {
+        throw new EntryOutputContractError(entry.name, decoded.issues);
+    }
+    return decoded.value;
+}

package/dist/factory.d.ts

@@ -0,0 +1,16 @@
+import type { JsonValue } from "@alpacakit/core";
+import type { ChannelSegmentOverride, CommandDocumentationInput, EntryChannelBinding, EntryDefinition, EntryDefinitionWithOutput, EntryTreeDefinition, EntryTreeEndpoint, EntryTreeNode, ParameterSet } from "./model.js";
+import type { Channel } from "./values.js";
+export declare function defineEntryTree(root: EntryTreeNode): EntryTreeDefinition;
+export declare function defineEntryNode(input: {
+    readonly name: string;
+    readonly description: string;
+    readonly documentation?: CommandDocumentationInput;
+    readonly segments?: readonly ChannelSegmentOverride[];
+    readonly endpoints?: readonly EntryTreeEndpoint[];
+    readonly children?: readonly EntryTreeNode[];
+}): EntryTreeNode;
+export declare function mergeEntryTreeNodes(nodes: readonly EntryTreeNode[]): readonly EntryTreeNode[];
+export declare function defineEntryEndpoint<const Name extends string, const Parameters extends ParameterSet, Projection, Output extends JsonValue>(entry: EntryDefinitionWithOutput<Name, Parameters, Projection, Output>, ...channels: readonly EntryChannelBinding<Channel, NoInfer<Parameters[number]["name"]>>[]): EntryTreeEndpoint<EntryDefinitionWithOutput<Name, Parameters, Projection, Output>>;
+export declare function defineEntryEndpoint<const Name extends string, const Parameters extends ParameterSet, Projection>(entry: EntryDefinition<Name, Parameters, Projection>, ...channels: readonly EntryChannelBinding<Channel, NoInfer<Parameters[number]["name"]>>[]): EntryTreeEndpoint<EntryDefinition<Name, Parameters, Projection>>;
+//# sourceMappingURL=factory.d.ts.map