kiriya 0.1.0

package/dist/src/modules/completion/presentation/completion.views.js

@@ -0,0 +1,6 @@
+import { message } from "../../../core/domain/message.js";
+/** The script exactly, so it can be piped into a file or evaluated. */
+export const scriptView = (output) => output.script.replace(/\n$/, "").split("\n");
+/** One suggestion per line: the value, a tab, and its description, which may be empty. */
+export const suggestView = (output, format) => output.suggestions.map((suggestion) => `${suggestion.value}\t${suggestion.description === null ? "" : format.text(message(suggestion.description))}`);
+//# sourceMappingURL=completion.views.js.map

package/dist/src/modules/config/application/config-commands.js

@@ -0,0 +1,14 @@
+import { RawReader } from "../../../core/domain/input-schema.js";
+export const noInput = { positionals: [], options: {}, parse: () => ({}) };
+export const keyInput = {
+    positionals: [{ name: "key", description: "config.arg.key", required: true, variadic: false }],
+    options: {},
+    parse: (raw) => ({ key: new RawReader(raw).positional(0) ?? "" }),
+};
+/** What every config command shares: they read or write one small local file. */
+export const CONFIG_COMMAND = {
+    idempotent: true,
+    usesNetwork: false,
+    runsUserCommands: false,
+};
+//# sourceMappingURL=config-commands.js.map

package/dist/src/modules/config/application/get-setting.use-case.js

@@ -0,0 +1,25 @@
+import { done } from "../../../core/domain/command.js";
+import { NotFoundError } from "../../../core/domain/errors.js";
+import { CONFIG_COMMAND, keyInput } from "./config-commands.js";
+export const getSpec = {
+    id: "config.get",
+    summary: "config.get.summary",
+    examples: ["kiriya config get plugins"],
+    safety: "read",
+    ...CONFIG_COMMAND,
+    input: keyInput,
+};
+export class GetSetting {
+    config;
+    spec = getSpec;
+    constructor(config) {
+        this.config = config;
+    }
+    async execute(input) {
+        const value = (await this.config.read())[input.key];
+        if (value === undefined)
+            throw new NotFoundError("config.get.not-set", { key: input.key });
+        return done({ key: input.key, value });
+    }
+}
+//# sourceMappingURL=get-setting.use-case.js.map

package/dist/src/modules/config/application/list-config-keys.use-case.js

@@ -0,0 +1,26 @@
+import { CONFIG_KEYS } from "../../../config/config-keys.js";
+import { done } from "../../../core/domain/command.js";
+import { message } from "../../../core/domain/message.js";
+import { CONFIG_COMMAND, noInput } from "./config-commands.js";
+export const keysSpec = {
+    id: "config.keys",
+    summary: "config.keys.summary",
+    examples: ["kiriya config keys"],
+    safety: "read",
+    ...CONFIG_COMMAND,
+    input: noInput,
+};
+export class ListConfigKeys {
+    spec = keysSpec;
+    execute() {
+        const keys = CONFIG_KEYS.map((entry) => ({
+            key: entry.key,
+            type: entry.type,
+            description: message(entry.description),
+            example: entry.example,
+            choices: entry.choices ?? null,
+        }));
+        return Promise.resolve(done({ keys }));
+    }
+}
+//# sourceMappingURL=list-config-keys.use-case.js.map

package/dist/src/modules/config/application/list-settings.use-case.js

@@ -0,0 +1,28 @@
+import { CONFIG_KEYS } from "../../../config/config-keys.js";
+import { checkConfigTypes, configKey } from "../../../core/application/config-values.js";
+import { done } from "../../../core/domain/command.js";
+import { byCodePoint } from "../../../core/domain/names.js";
+import { CONFIG_COMMAND, noInput } from "./config-commands.js";
+export const listSpec = {
+    id: "config.list",
+    summary: "config.list.summary",
+    examples: ["kiriya config list", "kiriya config list --json"],
+    safety: "read",
+    ...CONFIG_COMMAND,
+    input: noInput,
+};
+export class ListSettings {
+    config;
+    spec = listSpec;
+    constructor(config) {
+        this.config = config;
+    }
+    async execute() {
+        const values = await this.config.read();
+        checkConfigTypes(values, this.config.path);
+        const keys = [...new Set([...CONFIG_KEYS.map((entry) => entry.key), ...Object.keys(values)])].sort(byCodePoint);
+        const settings = keys.map((key) => ({ key, value: values[key] ?? null, known: configKey(key) !== undefined }));
+        return done({ path: this.config.path, settings });
+    }
+}
+//# sourceMappingURL=list-settings.use-case.js.map

package/dist/src/modules/config/application/set-setting.use-case.js

@@ -0,0 +1,53 @@
+import { checkConfigTypes, configKey } from "../../../core/application/config-values.js";
+import { done } from "../../../core/domain/command.js";
+import { RefusedError, UsageError } from "../../../core/domain/errors.js";
+import { RawReader } from "../../../core/domain/input-schema.js";
+import { looksSecret } from "../../../core/domain/secrets.js";
+import { CONFIG_COMMAND } from "./config-commands.js";
+export const setSpec = {
+    id: "config.set",
+    summary: "config.set.summary",
+    examples: ["kiriya config set plugins kiriya-plugin-example", "kiriya config set plugins ./team/plugin ./my/plugin"],
+    safety: "write",
+    ...CONFIG_COMMAND,
+    // Over MCP an agent could turn on more tools for itself, or list a plugin that runs its own code.
+    terminalOnly: true,
+    input: {
+        positionals: [
+            { name: "key", description: "config.set.arg.key", required: true, variadic: false },
+            { name: "values", description: "config.set.arg.values", required: true, variadic: true },
+        ],
+        options: {},
+        parse(raw) {
+            const reader = new RawReader(raw);
+            return { key: reader.positional(0) ?? "", values: reader.positionalsFrom(1) };
+        },
+    },
+};
+export class SetSetting {
+    config;
+    spec = setSpec;
+    constructor(config) {
+        this.config = config;
+    }
+    async execute(input) {
+        const known = configKey(input.key);
+        if (known === undefined)
+            throw new UsageError("config.set.unknown-key", { key: input.key });
+        if (known.type === "string" && input.values.length !== 1) {
+            throw new UsageError("config.set.one-value", { key: input.key });
+        }
+        if (known.choices !== undefined && !known.choices.includes(input.values[0] ?? "")) {
+            throw new UsageError("config.set.not-a-choice", { key: input.key, choices: known.choices.join(", ") });
+        }
+        // The file sits in plain text in the user's profile, so it never takes a secret.
+        if (input.values.some(looksSecret))
+            throw new RefusedError("config.set.secret");
+        const current = await this.config.read();
+        checkConfigTypes(current, this.config.path);
+        const value = known.type === "list" ? [...input.values] : (input.values[0] ?? "");
+        await this.config.write({ ...current, [input.key]: value });
+        return done({ key: input.key, value, previous: current[input.key] ?? null });
+    }
+}
+//# sourceMappingURL=set-setting.use-case.js.map

package/dist/src/modules/config/application/show-config-path.use-case.js

@@ -0,0 +1,21 @@
+import { done } from "../../../core/domain/command.js";
+import { CONFIG_COMMAND, noInput } from "./config-commands.js";
+export const pathSpec = {
+    id: "config.path",
+    summary: "config.path.summary",
+    examples: ["kiriya config path"],
+    safety: "read",
+    ...CONFIG_COMMAND,
+    input: noInput,
+};
+export class ShowConfigPath {
+    config;
+    spec = pathSpec;
+    constructor(config) {
+        this.config = config;
+    }
+    async execute() {
+        return done({ path: this.config.path, exists: await this.config.exists() });
+    }
+}
+//# sourceMappingURL=show-config-path.use-case.js.map

package/dist/src/modules/config/application/unset-setting.use-case.js

@@ -0,0 +1,28 @@
+import { done } from "../../../core/domain/command.js";
+import { CONFIG_COMMAND, keyInput } from "./config-commands.js";
+export const unsetSpec = {
+    id: "config.unset",
+    summary: "config.unset.summary",
+    examples: ["kiriya config unset plugins"],
+    safety: "write",
+    ...CONFIG_COMMAND,
+    // Over MCP an agent could take back a limit the user set.
+    terminalOnly: true,
+    input: keyInput,
+};
+export class UnsetSetting {
+    config;
+    spec = unsetSpec;
+    constructor(config) {
+        this.config = config;
+    }
+    async execute(input) {
+        const current = await this.config.read();
+        if (!(input.key in current))
+            return done({ key: input.key, removed: false });
+        const remaining = Object.fromEntries(Object.entries(current).filter(([key]) => key !== input.key));
+        await this.config.write(remaining);
+        return done({ key: input.key, removed: true });
+    }
+}
+//# sourceMappingURL=unset-setting.use-case.js.map

package/dist/src/modules/config/config.module.js

@@ -0,0 +1,28 @@
+import { GetSetting } from "./application/get-setting.use-case.js";
+import { ListConfigKeys } from "./application/list-config-keys.use-case.js";
+import { ListSettings } from "./application/list-settings.use-case.js";
+import { SetSetting } from "./application/set-setting.use-case.js";
+import { ShowConfigPath } from "./application/show-config-path.use-case.js";
+import { UnsetSetting } from "./application/unset-setting.use-case.js";
+import { getView, keysView, listView, pathView, setView, unsetView } from "./presentation/config.views.js";
+export const configModule = {
+    id: "config",
+    summary: "config.summary",
+    about: "config.about",
+    examples: [
+        "kiriya config path",
+        "kiriya config keys",
+        "kiriya config set plugins kiriya-plugin-example",
+        "kiriya config set mcp.allowWrite true",
+    ],
+    guide: "https://github.com/SatPaingOo/kiriya/blob/main/docs/modules/config.md",
+    register(registrar, ports) {
+        registrar.add(new ShowConfigPath(ports.config), pathView);
+        registrar.add(new ListConfigKeys(), keysView);
+        registrar.add(new ListSettings(ports.config), listView);
+        registrar.add(new GetSetting(ports.config), getView);
+        registrar.add(new SetSetting(ports.config), setView);
+        registrar.add(new UnsetSetting(ports.config), unsetView);
+    },
+};
+//# sourceMappingURL=config.module.js.map

package/dist/src/modules/config/presentation/config.views.js

@@ -0,0 +1,33 @@
+import { message } from "../../../core/domain/message.js";
+const shown = (value) => (typeof value === "string" ? value : value.join(", "));
+/** Only the path, so `$(kiriya config path)` works in a script. */
+export const pathView = (output) => [output.path];
+export const keysView = (output, format) => output.keys.flatMap((entry) => [
+    `${format.bold(entry.key)}  ${format.dim(entry.type)}  ${format.text(entry.description)}`,
+    ...(entry.choices === null
+        ? []
+        : [format.dim(`  ${format.text(message("config.keys.choices", { choices: entry.choices.join(", ") }))}`)]),
+    format.dim(`  ${format.text(message("config.keys.example", { command: `kiriya config set ${entry.key} ${entry.example}` }))}`),
+]);
+export const listView = (output, format) => {
+    const width = Math.max(0, ...output.settings.map((setting) => setting.key.length));
+    return [
+        format.dim(output.path),
+        ...output.settings.map((setting) => {
+            const value = setting.value === null ? format.dim(format.text(message("config.list.not-set"))) : shown(setting.value);
+            const unknown = setting.known ? "" : `  ${format.dim(format.text(message("config.list.unknown")))}`;
+            return `  ${setting.key.padEnd(width)}  ${value}${unknown}`;
+        }),
+    ];
+};
+/** One value per line, so a list setting can be read line by line. */
+export const getView = (output) => typeof output.value === "string" ? [output.value] : [...output.value];
+export const setView = (output, format) => [
+    format.green(format.text(message("config.set.done", { key: output.key, value: shown(output.value) }))),
+];
+export const unsetView = (output, format) => [
+    output.removed
+        ? format.green(format.text(message("config.unset.done", { key: output.key })))
+        : format.dim(format.text(message("config.unset.not-set", { key: output.key }))),
+];
+//# sourceMappingURL=config.views.js.map

package/dist/src/modules/convert/application/convert-case.use-case.js

@@ -0,0 +1,38 @@
+import { done } from "../../../core/domain/command.js";
+import { UsageError } from "../../../core/domain/errors.js";
+import { RawReader } from "../../../core/domain/input-schema.js";
+import { TEXT_CASES, toCase } from "../../../core/domain/text-case.js";
+import { CONVERTER, fileOption, inputText, readInput, valuePositional } from "./convert-input.js";
+export const caseSpec = {
+    id: "convert.case",
+    summary: "convert.case.summary",
+    examples: ['kiriya convert case "user profile id" --to camel', "kiriya convert case OrderItems --to kebab"],
+    ...CONVERTER,
+    input: {
+        positionals: [valuePositional],
+        options: {
+            to: { type: "string", description: "convert.case.option.to", valueName: `<${TEXT_CASES.join("|")}>` },
+            file: fileOption,
+        },
+        parse(raw) {
+            const reader = new RawReader(raw);
+            if (reader.string("to") === undefined)
+                throw new UsageError("convert.case.to-required");
+            return { value: reader.positional(0), file: reader.string("file"), to: reader.choice("to", TEXT_CASES, "kebab") };
+        },
+    },
+};
+export class ConvertCase {
+    sources;
+    spec = caseSpec;
+    constructor(sources) {
+        this.sources = sources;
+    }
+    async execute(input, context) {
+        const text = inputText(await readInput(this.sources, context.cwd, input.value, input.file));
+        // Each line changes on its own, so a list of names stays a list.
+        const lines = text.split(/\r?\n/).map((line) => toCase(line, input.to));
+        return done({ output: lines.join("\n") });
+    }
+}
+//# sourceMappingURL=convert-case.use-case.js.map

package/dist/src/modules/convert/application/convert-codecs.use-case.js

@@ -0,0 +1,92 @@
+import { done } from "../../../core/domain/command.js";
+import { fromBase64, fromHex, toBase64, toHex, utf8Text } from "../../../core/domain/encodings.js";
+import { OperationFailedError, UsageError } from "../../../core/domain/errors.js";
+import { RawReader } from "../../../core/domain/input-schema.js";
+import { CONVERTER, fileOption, inputBytes, inputText, readInput, valuePositional, } from "./convert-input.js";
+function decodedText(bytes, invalid) {
+    if (bytes === null)
+        throw new UsageError(invalid);
+    const text = utf8Text(bytes);
+    if (text === null)
+        throw new OperationFailedError("convert.decoded-binary");
+    return text;
+}
+const CODECS = {
+    base64: {
+        encode: (input, urlSafe) => toBase64(inputBytes(input), urlSafe),
+        decode: (text) => decodedText(fromBase64(text), "convert.base64.invalid"),
+    },
+    hex: {
+        encode: (input) => toHex(inputBytes(input)),
+        decode: (text) => decodedText(fromHex(text), "convert.hex.invalid"),
+    },
+    url: {
+        encode: (input) => encodeURIComponent(inputText(input)),
+        decode: (text) => {
+            try {
+                return decodeURIComponent(text);
+            }
+            catch {
+                throw new UsageError("convert.url.invalid");
+            }
+        },
+    },
+};
+const SUMMARIES = {
+    base64: "convert.base64.summary",
+    hex: "convert.hex.summary",
+    url: "convert.url.summary",
+};
+const EXAMPLES = {
+    base64: [
+        'kiriya convert base64 "hello"',
+        "kiriya convert base64 --decode aGVsbG8=",
+        "kiriya convert base64 --file logo.png",
+    ],
+    hex: ['kiriya convert hex "hello"', "kiriya convert hex --decode 68656c6c6f"],
+    url: ['kiriya convert url "a b&c"', "kiriya convert url --decode a%20b%26c"],
+};
+function codecSpec(name) {
+    const options = {
+        decode: { type: "boolean", description: "convert.option.decode", short: "d" },
+        file: fileOption,
+    };
+    if (name === "base64")
+        options["url"] = { type: "boolean", description: "convert.base64.option.url" };
+    return {
+        id: `convert.${name}`,
+        summary: SUMMARIES[name],
+        examples: EXAMPLES[name],
+        ...CONVERTER,
+        input: {
+            positionals: [valuePositional],
+            options,
+            parse(raw) {
+                const reader = new RawReader(raw);
+                return {
+                    value: reader.positional(0),
+                    file: reader.string("file"),
+                    decode: reader.flag("decode"),
+                    urlSafe: reader.flag("url"),
+                };
+            },
+        },
+    };
+}
+/** One command per codec: `convert base64`, `convert hex` and `convert url`. */
+export class ConvertCodec {
+    sources;
+    spec;
+    codec;
+    constructor(name, sources) {
+        this.sources = sources;
+        this.spec = codecSpec(name);
+        this.codec = CODECS[name];
+    }
+    async execute(input, context) {
+        const read = await readInput(this.sources, context.cwd, input.value, input.file);
+        const output = input.decode ? this.codec.decode(inputText(read)) : this.codec.encode(read, input.urlSafe);
+        return done({ output });
+    }
+}
+//# sourceMappingURL=convert-codecs.use-case.js.map

package/dist/src/modules/convert/application/convert-input.js

@@ -0,0 +1,16 @@
+export { inputBytes, inputText, readInput } from "../../../core/application/text-input.js";
+/** Every conversion runs on this machine, changes nothing, and gives the same result for the same input. */
+export const CONVERTER = { safety: "read", idempotent: true, usesNetwork: false, runsUserCommands: false };
+export const valuePositional = {
+    name: "value",
+    description: "convert.arg.value",
+    required: false,
+    variadic: false,
+};
+export const fileOption = {
+    type: "string",
+    description: "convert.option.file",
+    valueName: "<path>",
+    path: true,
+};
+//# sourceMappingURL=convert-input.js.map

package/dist/src/modules/convert/application/convert-json.use-case.js

@@ -0,0 +1,51 @@
+import { done } from "../../../core/domain/command.js";
+import { RawReader } from "../../../core/domain/input-schema.js";
+import { message } from "../../../core/domain/message.js";
+import { findJsonProblem } from "../domain/json-syntax.js";
+import { CONVERTER, fileOption, inputText, readInput, valuePositional } from "./convert-input.js";
+export const jsonSpec = {
+    id: "convert.json",
+    summary: "convert.json.summary",
+    examples: [
+        "kiriya convert json --file package.json",
+        "kiriya convert json --minify < data.json",
+        "kiriya convert json --check --file config.json",
+    ],
+    ...CONVERTER,
+    input: {
+        positionals: [valuePositional],
+        options: {
+            minify: { type: "boolean", description: "convert.json.option.minify" },
+            check: { type: "boolean", description: "convert.json.option.check" },
+            file: fileOption,
+        },
+        parse(raw) {
+            const reader = new RawReader(raw);
+            return {
+                value: reader.positional(0),
+                file: reader.string("file"),
+                minify: reader.flag("minify"),
+                check: reader.flag("check"),
+            };
+        },
+    },
+};
+export class ConvertJson {
+    sources;
+    spec = jsonSpec;
+    constructor(sources) {
+        this.sources = sources;
+    }
+    async execute(input, context) {
+        const text = inputText(await readInput(this.sources, context.cwd, input.value, input.file));
+        const problem = findJsonProblem(text);
+        if (problem !== null) {
+            const where = { line: problem.line, column: problem.column };
+            return done({ valid: false, output: null, ...where }, { failures: [message("convert.json.invalid", where)] });
+        }
+        const parsed = JSON.parse(text);
+        const output = input.check ? null : JSON.stringify(parsed, null, input.minify ? undefined : 2);
+        return done({ valid: true, output, line: null, column: null });
+    }
+}
+//# sourceMappingURL=convert-json.use-case.js.map

package/dist/src/modules/convert/application/convert-time.use-case.js

@@ -0,0 +1,39 @@
+import { done } from "../../../core/domain/command.js";
+import { UsageError } from "../../../core/domain/errors.js";
+import { RawReader } from "../../../core/domain/input-schema.js";
+import { EPOCH_UNITS, parseMoment } from "../domain/moments.js";
+import { CONVERTER } from "./convert-input.js";
+export const timeSpec = {
+    id: "convert.time",
+    summary: "convert.time.summary",
+    examples: [
+        "kiriya convert time",
+        "kiriya convert time 1767225600",
+        "kiriya convert time 2026-01-31T12:00:00Z --json",
+    ],
+    ...CONVERTER,
+    // Without a value it shows now.
+    idempotent: false,
+    input: {
+        positionals: [{ name: "value", description: "convert.time.arg.value", required: false, variadic: false }],
+        options: { unit: { type: "string", description: "convert.time.option.unit", valueName: "<auto|seconds|ms>" } },
+        parse(raw) {
+            const reader = new RawReader(raw);
+            return { value: reader.positional(0), unit: reader.choice("unit", EPOCH_UNITS, "auto") };
+        },
+    },
+};
+export class ConvertTime {
+    clock;
+    spec = timeSpec;
+    constructor(clock) {
+        this.clock = clock;
+    }
+    execute(input) {
+        const ms = input.value === undefined ? this.clock.now() : parseMoment(input.value, input.unit);
+        if (ms === null)
+            throw new UsageError("convert.time.invalid", { value: input.value ?? "" });
+        return Promise.resolve(done({ iso: new Date(ms).toISOString(), epochSeconds: Math.floor(ms / 1000), epochMs: ms }));
+    }
+}
+//# sourceMappingURL=convert-time.use-case.js.map

package/dist/src/modules/convert/application/decode-jwt.use-case.js

@@ -0,0 +1,52 @@
+import { done } from "../../../core/domain/command.js";
+import { UsageError } from "../../../core/domain/errors.js";
+import { RawReader } from "../../../core/domain/input-schema.js";
+import { message } from "../../../core/domain/message.js";
+import { claimTime, decodeJwt } from "../domain/jwt.js";
+import { CONVERTER, fileOption, inputText, readInput, valuePositional } from "./convert-input.js";
+export const jwtSpec = {
+    id: "convert.jwt",
+    summary: "convert.jwt.summary",
+    examples: ["kiriya convert jwt < token.txt", "kiriya convert jwt --file token.txt --json"],
+    ...CONVERTER,
+    // Whether a token has expired depends on when it is asked.
+    idempotent: false,
+    input: {
+        positionals: [valuePositional],
+        options: { file: fileOption },
+        parse(raw) {
+            const reader = new RawReader(raw);
+            return { value: reader.positional(0), file: reader.string("file") };
+        },
+    },
+};
+const isoTime = (ms) => (ms === null ? null : new Date(ms).toISOString());
+/** Decodes on this machine and never checks the signature: the claims say what the token says, not that it is genuine. */
+export class DecodeJwt {
+    sources;
+    clock;
+    spec = jwtSpec;
+    constructor(sources, clock) {
+        this.sources = sources;
+        this.clock = clock;
+    }
+    async execute(input, context) {
+        const read = await readInput(this.sources, context.cwd, input.value, input.file);
+        const decoded = decodeJwt(inputText(read));
+        if (decoded === null)
+            throw new UsageError("convert.jwt.invalid");
+        const expires = claimTime(decoded.payload, "exp");
+        const warnings = [message("convert.jwt.unverified")];
+        if (read.from === "argument")
+            warnings.push(message("convert.jwt.from-argument"));
+        return done({
+            header: decoded.header,
+            payload: decoded.payload,
+            issuedAt: isoTime(claimTime(decoded.payload, "iat")),
+            notBefore: isoTime(claimTime(decoded.payload, "nbf")),
+            expiresAt: isoTime(expires),
+            expired: expires === null ? null : expires <= this.clock.now(),
+        }, { warnings });
+    }
+}
+//# sourceMappingURL=decode-jwt.use-case.js.map

package/dist/src/modules/convert/convert.module.js

@@ -0,0 +1,29 @@
+import { ConvertCase } from "./application/convert-case.use-case.js";
+import { ConvertCodec } from "./application/convert-codecs.use-case.js";
+import { ConvertJson } from "./application/convert-json.use-case.js";
+import { ConvertTime } from "./application/convert-time.use-case.js";
+import { DecodeJwt } from "./application/decode-jwt.use-case.js";
+import { jsonView, jwtView, outputView, timeView } from "./presentation/convert.views.js";
+export const convertModule = {
+    id: "convert",
+    summary: "convert.summary",
+    about: "convert.about",
+    examples: [
+        "kiriya convert base64 --decode aGVsbG8=",
+        "kiriya convert json --file package.json",
+        "kiriya convert jwt --file token.txt",
+        "kiriya convert time 1767225600",
+    ],
+    guide: "https://github.com/SatPaingOo/kiriya/blob/main/docs/modules/convert.md",
+    register(registrar, ports) {
+        const sources = { stdin: ports.stdin, fileSystem: ports.fileSystem, content: ports.fileContent };
+        registrar.add(new ConvertCodec("base64", sources), outputView);
+        registrar.add(new ConvertCodec("hex", sources), outputView);
+        registrar.add(new ConvertCodec("url", sources), outputView);
+        registrar.add(new ConvertJson(sources), jsonView);
+        registrar.add(new DecodeJwt(sources, ports.clock), jwtView);
+        registrar.add(new ConvertTime(ports.clock), timeView);
+        registrar.add(new ConvertCase(sources), outputView);
+    },
+};
+//# sourceMappingURL=convert.module.js.map