@alpacakit/channels 0.1.0-beta.36 → 0.1.0-beta.39

package/dist/cli-tree.js

@@ -1,423 +1,197 @@
 import { coerceCliArgvValue } from "./cli-coercion.js";
-import { CLI_OPTION_ACTION_KIND, compileCliBinding, } from "./cli-compiler.js";
+import { compileCliBinding, projectCliParameters, } 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_TREE_VALIDATION_ISSUE = {
-    subcommandHintWithoutChildren: "CLI subcommand hint requires at least one child command",
-};
-const EMPTY_CLI_GROUP_HELP = {
+import { CLI_ARG_KIND, } from "./cli-model.js";
+import { compileInputPlan } from "./input-compiler.js";
+import { ownedArray, ownedRecord } from "./owned.js";
+import { packRegistrationCollection, } from "./registration.js";
+import { EntryTreeDefinitionError, findChannelBinding, formatTreePath, isEntryTreeDefinition, validateEntryTreeStructure, } from "./schema.js";
+import { isChannelPayload, PAYLOAD_KIND } from "./tree-internal.js";
+import { CHANNEL } from "./values.js";
+const EMPTY_CLI_GROUP_HELP = ownedRecord({
     subcommandHint: null,
-    examples: [],
-};
-export function createCliRouter(tree) {
-    const root = compileCliTree(tree);
-    const endpointLocations = listCliEndpointLocations(root);
-    return {
-        help: root.help,
-        endpoints: endpointLocations.map((location) => location.endpoint),
-        endpointLocations,
-        resolve: (argv) => resolveCli(root, argv),
-    };
-}
-function listCliEndpointLocations(root) {
-    const locations = [];
-    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) {
-            locations.push({
-                endpoint: node.endpoint.endpoint,
-                path: node.path.slice(1),
-                binding: node.endpoint.binding,
-            });
-        }
-        pending.push(...node.childByToken.values());
-    }
-    return locations;
-}
-function compileCliTree(tree) {
-    const issues = [...validateEntryTreeStructure(tree)];
-    const nodeRecords = new Map();
-    const nodeQueue = [{ node: tree.root, parentPath: [], root: true }];
-    for (const current of nodeQueue) {
-        const segment = cliSegmentFor(current.node, current.parentPath, current.root, issues);
-        const path = current.root
-            ? [current.node.name]
-            : [...current.parentPath, segment.token];
-        nodeRecords.set(current.node, {
-            path,
-            segment,
-            endpoint: cliEndpointFor(current.node, path, issues),
-        });
-        nodeQueue.push(...current.node.children.map((node) => ({
-            node,
-            parentPath: path,
-            root: false,
-        })));
-    }
-    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);
-        }
-        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);
-    }
+    examples: ownedArray([]),
+});
+export function collectCliCommands(source) {
+    const structuralIssues = validateEntryTreeStructure(source);
+    if (structuralIssues.length > 0) {
+        throw new EntryTreeDefinitionError(structuralIssues);
+    }
+    const issues = [];
+    const root = isEntryTreeDefinition(source)
+        ? compileTreeRoot(source.root, issues)
+        : compileVirtualRoot(source, issues);
     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, help: EMPTY_CLI_GROUP_HELP };
-    }
-    else if (!isCliSegment(override.segment)) {
-        issues.push(`${formatTreePath(path)}: invalid CLI segment override`);
-        segment = { token: node.name, help: EMPTY_CLI_GROUP_HELP };
-    }
-    else {
-        segment = override.segment;
-    }
-    validateCliHelpExamples(segment.help.examples, formatTreePath(path), issues);
-    if (!root) {
-        validateCliCommandToken(segment.token, path, issues);
-    }
-    return segment;
+    return ownedRecord({ root });
+}
+function compileTreeRoot(root, issues) {
+    const segment = cliSegmentFor(root, [], issues);
+    return compileNode(root, segment, [], true, issues);
+}
+function compileVirtualRoot(node, issues) {
+    const segment = cliSegmentFor(node, [node.name], issues);
+    const child = compileNode(node, segment, [segment.token], false, issues);
+    const help = emptyVirtualRootHelp(child.help);
+    return ownedRecord({
+        token: "",
+        path: ownedArray([]),
+        description: "",
+        documentation: ownedRecord({
+            remarks: ownedArray([]),
+            relatedDocs: ownedArray([]),
+        }),
+        help,
+        commands: packRegistrationCollection([]),
+        children: ownedArray([child]),
+    });
 }
-function validateCliCommandToken(token, path, issues) {
-    if (token.length === 0) {
-        issues.push(`${formatTreePath(path)}: CLI segment token must not be empty`);
-        return;
-    }
-    if (classifyCliArgumentToken(token) !== CLI_ARGUMENT_TOKEN_KIND.value) {
-        issues.push(`${formatTreePath(path)}: CLI segment token ${JSON.stringify(token)} is unreachable`);
-    }
+function compileNode(node, segment, path, root, issues) {
+    const token = segment.token;
+    validateCliToken(token, path, issues);
+    const compiledEndpoint = cliEndpointFor(node, path, issues);
+    const children = node.children.map((child) => {
+        const childSegment = cliSegmentFor(child, [...path, child.name], issues);
+        return compileNode(child, childSegment, [...path, childSegment.token], false, issues);
+    });
+    validateChildTokens(path, children, issues);
+    if (segment.help.subcommandHint !== null && children.length === 0) {
+        issues.push(`${formatTreePath(path)}: CLI subcommand hint requires children`);
+    }
+    const help = createCliHelpSurface({
+        node,
+        segment,
+        endpoint: compiledEndpoint,
+        childHelp: children.map((child) => child.help),
+        root,
+    });
+    const registrations = compiledEndpoint === null
+        ? []
+        : [createCliRegistration(compiledEndpoint, path)];
+    return ownedRecord({
+        token,
+        path: ownedArray(path),
+        description: node.description,
+        documentation: node.documentation,
+        help,
+        commands: packRegistrationCollection(registrations),
+        children: ownedArray(children),
+    });
 }
 function cliEndpointFor(node, path, issues) {
-    const endpoints = node.endpoints.flatMap((endpoint) => findChannelBinding(endpoint, CHANNEL.cli) ? [endpoint] : []);
+    const endpoints = [
+        ...new Set(node.endpoints.filter((endpoint) => endpoint.channels.some((binding) => binding.channel === CHANNEL.cli))),
+    ];
+    const location = formatTreePath(path);
     if (endpoints.length > 1) {
-        issues.push(`${formatTreePath(path)}: more than one public CLI endpoint`);
+        issues.push(`${location}: different CLI endpoints occupy the same path`);
     }
     const endpoint = endpoints[0];
-    if (!endpoint) {
+    if (endpoint === undefined) {
         return null;
     }
     const channelBinding = findChannelBinding(endpoint, CHANNEL.cli);
-    if (!channelBinding || !isCliEntryBinding(channelBinding.binding)) {
-        issues.push(`${formatTreePath(path)}: invalid CLI endpoint binding`);
+    if (channelBinding === null || !isCliChannelBinding(channelBinding)) {
+        issues.push(`${location}: invalid CLI endpoint binding`);
         return null;
     }
-    const location = `${formatTreePath(path)}#${endpoint.entry.name}`;
-    const compiled = compileCliBinding(endpoint, channelBinding.binding, location, issues);
+    const compiled = compileCliBinding(endpoint, channelBinding.binding, `${location}#${endpoint.entry.name}`, issues);
     validateCliCommandHelp(compiled, location, issues);
     return compiled;
 }
-function validateCliChildren(path, children, issues) {
-    const tokens = new Map();
-    for (const child of children) {
-        const token = child.segment.token;
-        const owner = tokens.get(token);
-        if (owner !== undefined) {
-            issues.push(`${formatTreePath(path)}: CLI sibling token 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;
+function createCliRegistration(compiled, path) {
+    const input = compileInputPlan({
+        entry: compiled.endpoint.entry,
+        bindings: compiled.parameterBindings,
+    });
+    const rows = new Map(compiled.binding.parameters.map((row) => [row.parameterName, row]));
+    const parseOptions = (raw) => input.parseCoerced(raw, (parameter, value) => {
+        const row = rows.get(parameter.name);
+        if (row === undefined) {
+            throw new Error(`Missing compiled CLI binding for ${parameter.name}`);
         }
-        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)),
+        return coerceCliValue(parameter, row, value);
+    });
+    const channelBinding = findChannelBinding(compiled.endpoint, CHANNEL.cli);
+    if (channelBinding === null) {
+        throw new Error("Compiled CLI endpoint lost its binding");
+    }
+    return ownedRecord({
+        endpoint: compiled.endpoint,
+        entry: compiled.endpoint.entry,
+        binding: channelBinding,
+        path: ownedArray(path),
+        parameters: projectCliParameters(compiled),
+        input: ownedRecord({
+            schema: input.schema,
+            parse: input.parse,
+            project: input.project,
+            parseOptions,
+        }),
+        handler: compiled.endpoint.handler,
     });
-    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 coerceCliValue(parameter, row, raw) {
+    const expanded = row.kind === CLI_ARG_KIND.option && row.repeatable && row.coercion === null
+        ? expandCommaSeparated(raw)
+        : raw;
+    return coerceCliArgvValue(parameter.name, parameter.codec.shape, expanded, row.coercion);
 }
-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 expandCommaSeparated(raw) {
+    const values = Array.isArray(raw) ? raw : [raw];
+    return values.flatMap((value) => typeof value === "string" ? value.split(",") : [value]);
 }
-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);
+function cliSegmentFor(node, path, issues) {
+    const override = node.segments.find((row) => row.channel === CHANNEL.cli);
+    if (override === undefined) {
+        return ownedRecord({ token: node.name, help: EMPTY_CLI_GROUP_HELP });
     }
-    const option = action.option;
-    const value = inlineValue ?? input.argv[input.index + 1];
-    if (value === undefined) {
-        return invalidCliParameter(option.parameter.name, `${flag} requires a value`);
+    if (!isCliSegment(override.segment)) {
+        issues.push(`${formatTreePath(path)}: invalid CLI segment override`);
+        return ownedRecord({ token: node.name, help: EMPTY_CLI_GROUP_HELP });
     }
-    storeOptionValue(input.raw, option, value);
-    return {
-        kind: CLI_PARSE_RESULT_KIND.parsed,
-        consumedNext: inlineValue === undefined,
-    };
+    validateCliHelpExamples(override.segment.help.examples, formatTreePath(path), issues);
+    return override.segment;
 }
-function setCliBooleanValue(raw, action, flag, inlineValue) {
-    if (inlineValue !== undefined) {
-        return invalidCliParameter(action.parameterName, `${flag} does not take a value`);
+function validateCliToken(token, path, issues) {
+    if (token.length === 0 || /\s/u.test(token)) {
+        issues.push(`${formatTreePath(path)}: CLI token must be non-empty and contain no whitespace`);
     }
-    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;
+function validateChildTokens(path, children, issues) {
+    const owners = new Map();
+    for (const child of children) {
+        const owner = owners.get(child.token);
+        if (owner !== undefined) {
+            issues.push(`${formatTreePath(path)}: CLI child token ${JSON.stringify(child.token)} collides between ${owner} and ${child.description}`);
         }
         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)];
+            owners.set(child.token, child.description);
+        }
+    }
+}
+function emptyVirtualRootHelp(child) {
+    return ownedRecord({
+        name: "",
+        token: null,
+        description: "",
+        optionGroups: ownedArray([]),
+        positionals: ownedArray([]),
+        children: ownedArray([child]),
+        remarks: ownedArray([]),
+        relatedDocs: ownedArray([]),
+        usages: ownedArray(["<command>"]),
+        examples: ownedArray([]),
+        subcommandHint: null,
+    });
 }
-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 isCliEntryBinding(value) {
+    return isChannelPayload(PAYLOAD_KIND.cliBinding, value);
 }
-function invalidCliInput(issue) {
-    return {
-        kind: CLI_ROUTER_RESULT_KIND.invalidInput,
-        issues: [issue],
-    };
+function isCliChannelBinding(binding) {
+    return binding.channel === CHANNEL.cli && isCliEntryBinding(binding.binding);
 }
-function invalidCliParameter(parameterName, issue) {
-    return {
-        kind: CLI_ROUTER_RESULT_KIND.invalidParameter,
-        parameterName,
-        issues: [issue],
-    };
+function isCliSegment(value) {
+    return isChannelPayload(PAYLOAD_KIND.cliSegment, value);
 }

package/dist/cli.d.ts

@@ -1,8 +1,4 @@
-export * from "./cli-application.js";
-export * from "./cli-executor.js";
 export * from "./cli-model.js";
-export * from "./cli-presentation.js";
-export * from "./cli-result-envelope.js";
-export { createCliRouter } from "./cli-tree.js";
+export { collectCliCommands } 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

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

package/dist/cli.js

@@ -1,7 +1,3 @@
-export * from "./cli-application.js";
-export * from "./cli-executor.js";
 export * from "./cli-model.js";
-export * from "./cli-presentation.js";
-export * from "./cli-result-envelope.js";
-export { createCliRouter } from "./cli-tree.js";
+export { collectCliCommands } 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

@@ -1,25 +1,27 @@
+import type { JsonValue } from "@alpacakit/core";
 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>;
+import type { ValueCodec, ValueShapeFor } from "./model.js";
+type JsonInput<Raw> = Raw extends JsonValue ? Raw : JsonValue;
+declare function defineValueCodec<Raw, Value extends JsonValue>(input: {
+    readonly schema: z.ZodType<Value, Raw>;
+    readonly shape: ValueShapeFor<JsonInput<Raw>>;
+}): ValueCodec<Raw, Value>;
+declare function stringCodec(): ValueCodec<string, string>;
+declare function booleanCodec(): ValueCodec<boolean, 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[]>;
+}): ValueCodec<number, number>;
+declare function stringEnumCodec<const Values extends readonly [string, ...string[]]>(values: Values): ValueCodec<Values[number], Values[number]>;
+declare function stringEnumListCodec<const Values extends readonly [string, ...string[]]>(values: Values): ValueCodec<readonly Values[number][], readonly Values[number][]>;
+declare function stringListCodec(): ValueCodec<readonly string[], 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;
+    readonly define: typeof defineValueCodec;
+    readonly string: typeof stringCodec;
+    readonly stringList: typeof stringListCodec;
+    readonly boolean: typeof booleanCodec;
+    readonly positiveInteger: typeof positiveIntegerCodec;
+    readonly stringEnum: typeof stringEnumCodec;
+    readonly stringEnumList: typeof stringEnumListCodec;
 };
 export {};
 //# sourceMappingURL=codecs.d.ts.map