kiriya 0.1.0

package/dist/src/core/application/plugin-loader.js

@@ -0,0 +1,100 @@
+import { KiriyaError } from "../domain/errors.js";
+import { message } from "../domain/message.js";
+const PLUGIN_ID = /^[a-z][a-z0-9-]*$/;
+/** Words the command line itself uses, which no module may take. */
+const RESERVED_IDS = new Set(["core", "help", "mcp", "version"]);
+/** The exported module, or why it is not one: the contract in docs/guides/plugins.md. */
+function checkShape(exports) {
+    const exported = typeof exports === "object" && exports !== null && "default" in exports
+        ? exports.default
+        : exports;
+    if (typeof exported !== "object" || exported === null)
+        return { problem: message("core.plugin.no-module") };
+    const { id, summary, register, messages } = exported;
+    if (typeof id !== "string" || !PLUGIN_ID.test(id))
+        return { problem: message("core.plugin.bad-id") };
+    if (typeof register !== "function")
+        return { problem: message("core.plugin.no-register", { id }) };
+    if (typeof messages !== "object" || messages === null) {
+        return { problem: message("core.plugin.no-messages", { id }) };
+    }
+    for (const [key, text] of Object.entries(messages)) {
+        if (!key.startsWith(`${id}.`) || typeof text !== "string") {
+            return { problem: message("core.plugin.bad-message", { id, key }) };
+        }
+    }
+    if (typeof summary !== "string" || !(summary in messages)) {
+        return { problem: message("core.plugin.no-summary", { id }) };
+    }
+    // Help reads these optional fields as it prints, so a wrong shape is refused here rather than failing there.
+    const { about, examples, guide } = exported;
+    if (about !== undefined && (typeof about !== "string" || !(about in messages))) {
+        return { problem: message("core.plugin.bad-about", { id }) };
+    }
+    if (examples !== undefined && !(Array.isArray(examples) && examples.every((line) => typeof line === "string"))) {
+        return { problem: message("core.plugin.bad-examples", { id }) };
+    }
+    if (guide !== undefined && (typeof guide !== "string" || !guide.startsWith("https://"))) {
+        return { problem: message("core.plugin.bad-guide", { id }) };
+    }
+    return { plugin: exported };
+}
+/**
+ * Loads the plugins the configuration lists and registers their commands. A plugin
+ * that cannot be found, imported, checked or registered is recorded and skipped, so
+ * one broken plugin never stops kiriya; `kiriya doctor` reports it.
+ */
+export class PluginLoader {
+    succeeded = [];
+    failed = [];
+    /** The English text of every loaded plugin's message keys. */
+    messages = {};
+    loaded() {
+        return this.succeeded;
+    }
+    problems() {
+        return this.failed;
+    }
+    async load(entries, baseDirectory, source, registry, ports) {
+        for (const entry of entries) {
+            let found;
+            try {
+                found = await source.load(entry, baseDirectory);
+            }
+            catch (error) {
+                if (!(error instanceof KiriyaError))
+                    throw error;
+                this.failed.push({ entry, reason: error.detail });
+                continue;
+            }
+            const checked = checkShape(found.exports);
+            if ("problem" in checked) {
+                this.failed.push({ entry, reason: checked.problem });
+                continue;
+            }
+            const { plugin } = checked;
+            if (RESERVED_IDS.has(plugin.id) || registry.module(plugin.id) !== undefined) {
+                this.failed.push({ entry, reason: message("core.plugin.taken", { id: plugin.id }) });
+                continue;
+            }
+            try {
+                registry.register(plugin, ports);
+            }
+            catch (error) {
+                const detail = error instanceof Error ? error.message : String(error);
+                this.failed.push({ entry, reason: message("core.plugin.register-failed", { id: plugin.id, detail }) });
+                continue;
+            }
+            Object.assign(this.messages, plugin.messages);
+            this.succeeded.push({
+                entry,
+                id: plugin.id,
+                name: found.name,
+                version: found.version,
+                location: found.location,
+                commands: registry.module(plugin.id)?.commands.size ?? 0,
+            });
+        }
+    }
+}
+//# sourceMappingURL=plugin-loader.js.map

package/dist/src/core/application/process-ending.js

@@ -0,0 +1,28 @@
+import { message } from "../domain/message.js";
+/** "node (4100), node (4200)", to show in a confirmation what is about to end. */
+export function processLabels(pids, names) {
+    return pids.map((pid) => `${names.get(pid) ?? "?"} (${pid})`).join(", ");
+}
+/** Ending results as output: a process already gone is a warning, and one that did not end is a failure. */
+export function reportEnded(results, names) {
+    const failures = [];
+    const warnings = [];
+    for (const result of results) {
+        const params = { name: names.get(result.pid) ?? "?", pid: result.pid, code: result.code ?? result.outcome };
+        if (result.outcome === "not-found")
+            warnings.push(message("core.end.gone", params));
+        if (result.outcome === "still-running")
+            failures.push(message("core.end.still-running", params));
+        if (result.outcome === "denied")
+            failures.push(message("core.end.denied", params));
+        if (result.outcome === "failed")
+            failures.push(message("core.end.failed", params));
+    }
+    const processes = results.map((result) => ({
+        pid: result.pid,
+        name: names.get(result.pid) ?? null,
+        outcome: result.outcome,
+    }));
+    return { processes, failures, warnings };
+}
+//# sourceMappingURL=process-ending.js.map

package/dist/src/core/application/root-scope.js

@@ -0,0 +1,123 @@
+import path from "node:path";
+import { NotFoundError, RefusedError } from "../domain/errors.js";
+import { hasGlob } from "../domain/glob.js";
+import { isInside } from "./paths.js";
+/** True when a path is a `.git` folder or lies inside one, in any letter case. */
+function insideGitFolder(target) {
+    return target.split(/[\\/]/).some((segment) => segment.toLowerCase() === ".git");
+}
+/** Every value given for an input the command marks as a path. */
+export function pathValues(schema, raw) {
+    const values = [];
+    schema.positionals.forEach((positional, index) => {
+        if (positional.path !== true)
+            return;
+        values.push(...raw.positionals.slice(index, positional.variadic ? undefined : index + 1));
+    });
+    for (const [name, option] of Object.entries(schema.options)) {
+        const value = raw.options[name];
+        if (option.path !== true || value === undefined || typeof value === "boolean")
+            continue;
+        values.push(...(typeof value === "string" ? [value] : value));
+    }
+    return values;
+}
+/**
+ * The folders an MCP client may reach. A path is inside when it lies under a root both
+ * as written and with every symlink followed, so neither `..` nor a link leads out.
+ */
+export class RootScope {
+    fileSystem;
+    start;
+    roots;
+    realRoots;
+    guarded;
+    constructor(fileSystem, 
+    /** Where relative paths start: the first root. */
+    start, roots, realRoots, guarded) {
+        this.fileSystem = fileSystem;
+        this.start = start;
+        this.roots = roots;
+        this.realRoots = realRoots;
+        this.guarded = guarded;
+    }
+    /**
+     * Folders resolve against `cwd`, which is the only root when none is given. Each must be
+     * a folder that exists. `guarded` files, such as kiriya's configuration file, stay out of
+     * reach of work that changes something even when a root holds them.
+     */
+    static async open(fileSystem, folders, cwd, guarded = []) {
+        const roots = [...new Set((folders.length === 0 ? [cwd] : folders).map((folder) => path.resolve(cwd, folder)))];
+        const realRoots = [];
+        for (const root of roots) {
+            if ((await fileSystem.stat(root))?.kind !== "directory")
+                throw new NotFoundError("core.mcp.root-missing", { path: root });
+            realRoots.push((await fileSystem.realPath(root)) ?? root);
+        }
+        const start = roots[0] ?? path.resolve(cwd);
+        return new RootScope(fileSystem, start, roots, realRoots, guarded.map((file) => path.resolve(cwd, file)));
+    }
+    /**
+     * RefusedError for the first value that leads outside every root. For work that
+     * `changes` something, a value that is a guarded file, or a folder holding one, is refused too.
+     */
+    async refuseOutside(values, changes = false) {
+        for (const value of values) {
+            for (const candidate of this.candidates(value)) {
+                const real = await this.real(candidate);
+                if (!this.within(candidate, this.roots) || real === null || !this.within(real, this.realRoots)) {
+                    throw new RefusedError("core.mcp.outside-roots", { path: value, roots: this.roots.join(", ") });
+                }
+                if (changes) {
+                    // git runs hooks and commands that its folder names, so a change there could run anything.
+                    if (insideGitFolder(candidate) || insideGitFolder(real)) {
+                        throw new RefusedError("core.mcp.git-folder", { path: value });
+                    }
+                    await this.refuseGuarded(value, candidate, real);
+                }
+            }
+        }
+    }
+    async refuseGuarded(value, candidate, real) {
+        for (const file of this.guarded) {
+            const realFile = await this.real(file);
+            if (isInside(file, candidate) || (realFile !== null && isInside(realFile, real))) {
+                throw new RefusedError("core.mcp.guarded", { path: value, file });
+            }
+        }
+    }
+    /** The path as written and, for a glob, the folder its expansion starts in, found the way `expandPaths` finds it. */
+    candidates(value) {
+        const whole = path.resolve(this.start, value);
+        if (!hasGlob(value))
+            return [whole];
+        const segments = (path.sep === "\\" ? value.split("\\").join("/") : value).split("/");
+        const firstGlob = segments.findIndex((segment) => hasGlob(segment));
+        return [whole, path.resolve(this.start, segments.slice(0, firstGlob).join("/") || ".")];
+    }
+    /**
+     * The path with the links of every part that exists followed. Null when an entry
+     * exists but cannot be followed, such as a link that leads nowhere, since writing
+     * through it would create whatever it names.
+     */
+    async real(target) {
+        const missing = [];
+        let current = target;
+        for (;;) {
+            const real = await this.fileSystem.realPath(current);
+            if (real !== null)
+                return path.join(real, ...missing);
+            if ((await this.fileSystem.lstat(current)) !== null)
+                return null;
+            const parent = path.dirname(current);
+            if (parent === current)
+                return null;
+            missing.unshift(path.basename(current));
+            current = parent;
+        }
+    }
+    within(target, roots) {
+        return roots.some((root) => isInside(target, root));
+    }
+}
+//# sourceMappingURL=root-scope.js.map

package/dist/src/core/application/safety.js

@@ -0,0 +1,26 @@
+import { RefusedError } from "../domain/errors.js";
+/** Refuses the whole command when any path is protected, before anything is asked or changed. */
+export function refuseProtected(guard, paths, cwd) {
+    for (const target of paths) {
+        const reason = guard.reasonFor(target, cwd);
+        if (reason !== null)
+            throw new RefusedError("core.guard.refused", { path: target, reason });
+    }
+}
+/** A yes-or-no question for work that can be undone; anything but yes stops the command. */
+export async function requireApproval(context, question, assumeYes) {
+    if (!(await context.confirmation.approve(question, assumeYes)))
+        throw new RefusedError("core.confirm.declined");
+}
+/**
+ * A typed confirmation for work that cannot be undone. A --confirm value that does
+ * not match stops the command before any prompt, since the plan is not what the script expected.
+ */
+export async function requireTypedConfirmation(context, warning, expected, provided) {
+    if (provided !== undefined && provided !== expected) {
+        throw new RefusedError("core.confirm.mismatch", { provided, expected });
+    }
+    if (!(await context.confirmation.typed(warning, expected, provided)))
+        throw new RefusedError("core.confirm.declined");
+}
+//# sourceMappingURL=safety.js.map

package/dist/src/core/application/text-input.js

@@ -0,0 +1,44 @@
+import path from "node:path";
+import { utf8Bytes, utf8Text } from "../domain/encodings.js";
+import { NotFoundError, OperationFailedError, UsageError } from "../domain/errors.js";
+import { formatBytes } from "../domain/values/bytes.js";
+/** Commands that take text work in memory, so input stops here. */
+export const INPUT_LIMIT_BYTES = 16 * 1024 * 1024;
+const BYTE_ORDER_MARK = String.fromCharCode(0xfeff);
+/** The value argument; everything piped in when it is `-` or missing; or a file's exact bytes with --file. */
+export async function readInput(sources, cwd, value, file) {
+    if (file !== undefined) {
+        if (value !== undefined)
+            throw new UsageError("core.input.twice");
+        const target = path.resolve(cwd, file);
+        const stat = await sources.fileSystem.stat(target);
+        if (stat?.kind !== "file")
+            throw new NotFoundError("core.fs.not-found", { path: target });
+        if (stat.size > INPUT_LIMIT_BYTES) {
+            throw new OperationFailedError("core.input.too-large", { limit: formatBytes(INPUT_LIMIT_BYTES) });
+        }
+        return { bytes: await sources.content.read(target), from: "file" };
+    }
+    if (value !== undefined && value !== "-")
+        return { bytes: utf8Bytes(value), from: "argument" };
+    if (value === undefined && sources.stdin.isTerminal)
+        throw new UsageError("core.input.missing");
+    return { bytes: await sources.stdin.read(INPUT_LIMIT_BYTES), from: "stdin" };
+}
+/**
+ * The input as text, without a byte order mark. Text piped in also loses one final
+ * line ending, so `echo` in bash and in PowerShell, which end lines differently,
+ * give the same result.
+ */
+export function inputText(input) {
+    const decoded = utf8Text(input.bytes);
+    if (decoded === null)
+        throw new UsageError("core.input.not-text");
+    const text = decoded.startsWith(BYTE_ORDER_MARK) ? decoded.slice(1) : decoded;
+    return input.from === "stdin" ? text.replace(/\r?\n$/, "") : text;
+}
+/** The bytes as given: a file or an argument exactly, piped text as inputText gives it. */
+export function inputBytes(input) {
+    return input.from === "stdin" ? utf8Bytes(inputText(input)) : input.bytes;
+}
+//# sourceMappingURL=text-input.js.map

package/dist/src/core/application/walk.js

@@ -0,0 +1,34 @@
+import path from "node:path";
+import { DEPENDENCY_DIRECTORIES } from "../../config/dependency-directories.js";
+import { KiriyaError } from "../domain/errors.js";
+import { byCodePoint, isHiddenName } from "../domain/names.js";
+/** Every entry below root in code-point order. Symlinks are listed, never followed; unreadable folders are skipped. */
+export async function* walk(fileSystem, root, options) {
+    const maxDepth = options.maxDepth ?? Number.POSITIVE_INFINITY;
+    async function* visit(dir, rel, depth) {
+        let entries;
+        try {
+            entries = [...(await fileSystem.readDirectory(dir))];
+        }
+        catch (error) {
+            if (error instanceof KiriyaError)
+                return;
+            throw error;
+        }
+        entries.sort((a, b) => byCodePoint(a.name, b.name));
+        for (const entry of entries) {
+            const skipped = isHiddenName(entry.name) || (entry.kind === "directory" && DEPENDENCY_DIRECTORIES.has(entry.name));
+            if (!options.all && skipped)
+                continue;
+            if (entry.kind === "directory" && options.skipDirectories?.has(entry.name) === true)
+                continue;
+            const childPath = path.join(dir, entry.name);
+            const childRel = rel === "" ? entry.name : `${rel}/${entry.name}`;
+            yield { path: childPath, rel: childRel, name: entry.name, depth, kind: entry.kind };
+            if (entry.kind === "directory" && depth < maxDepth)
+                yield* visit(childPath, childRel, depth + 1);
+        }
+    }
+    yield* visit(root, "", 1);
+}
+//# sourceMappingURL=walk.js.map

package/dist/src/core/domain/command.js

@@ -0,0 +1,8 @@
+export const SAFETY_LEVELS = ["read", "write", "destroy"];
+export function done(data, notes = {}) {
+    return { kind: "done", data, warnings: notes.warnings ?? [], failures: notes.failures ?? [] };
+}
+export function preview(data, applyFlag, warnings = []) {
+    return { kind: "preview", data, applyFlag, warnings };
+}
+//# sourceMappingURL=command.js.map

package/dist/src/core/domain/encodings.js

@@ -0,0 +1,70 @@
+const BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const BASE64_URL = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+/** Base64 with padding, or the URL-safe alphabet without it. */
+export function toBase64(bytes, urlSafe = false) {
+    const alphabet = urlSafe ? BASE64_URL : BASE64;
+    const pad = urlSafe ? "" : "=";
+    let text = "";
+    for (let index = 0; index < bytes.length; index += 3) {
+        const triple = ((bytes[index] ?? 0) << 16) | ((bytes[index + 1] ?? 0) << 8) | (bytes[index + 2] ?? 0);
+        text += alphabet.charAt((triple >> 18) & 63) + alphabet.charAt((triple >> 12) & 63);
+        text += index + 1 < bytes.length ? alphabet.charAt((triple >> 6) & 63) : pad;
+        text += index + 2 < bytes.length ? alphabet.charAt(triple & 63) : pad;
+    }
+    return text;
+}
+/** Standard or URL-safe base64, padded or not, with whitespace ignored; null when it is not base64. */
+export function fromBase64(text) {
+    const clean = text
+        .replace(/\s+/g, "")
+        .replace(/-/g, "+")
+        .replace(/_/g, "/")
+        .replace(/={0,2}$/, "");
+    if (!/^[A-Za-z0-9+/]*$/.test(clean) || clean.length % 4 === 1)
+        return null;
+    const bytes = new Uint8Array(Math.floor((clean.length * 3) / 4));
+    let buffer = 0;
+    let bits = 0;
+    let written = 0;
+    for (const char of clean) {
+        buffer = (buffer << 6) | BASE64.indexOf(char);
+        bits += 6;
+        if (bits >= 8) {
+            bits -= 8;
+            bytes[written] = (buffer >> bits) & 0xff;
+            written += 1;
+            buffer &= (1 << bits) - 1;
+        }
+    }
+    return bytes;
+}
+export function toHex(bytes) {
+    let text = "";
+    for (const byte of bytes)
+        text += byte.toString(16).padStart(2, "0");
+    return text;
+}
+/** Hexadecimal digits in pairs, with whitespace and a leading 0x ignored; null when it is not hexadecimal. */
+export function fromHex(text) {
+    const clean = text.replace(/\s+/g, "").replace(/^0x/i, "");
+    if (clean.length % 2 !== 0 || /[^0-9a-f]/i.test(clean))
+        return null;
+    const bytes = new Uint8Array(clean.length / 2);
+    for (let index = 0; index < bytes.length; index += 1) {
+        bytes[index] = Number.parseInt(clean.slice(index * 2, index * 2 + 2), 16);
+    }
+    return bytes;
+}
+export function utf8Bytes(text) {
+    return new TextEncoder().encode(text);
+}
+/** The bytes as UTF-8 text, or null when they are not valid UTF-8. */
+export function utf8Text(bytes) {
+    try {
+        return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=encodings.js.map

package/dist/src/core/domain/errors.js

@@ -0,0 +1,49 @@
+import { message } from "./message.js";
+export const ERROR_KINDS = [
+    "usage",
+    "not-found",
+    "conflict",
+    "refused",
+    "capability-unavailable",
+    "failed",
+    "interrupted",
+];
+/**
+ * Every error that crosses into a use case or presentation is one of these.
+ * Adapters wrap Node.js and operating-system failures before they cross inward.
+ */
+export class KiriyaError extends Error {
+    detail;
+    constructor(key, params = {}, options) {
+        super(key, options);
+        this.name = new.target.name;
+        this.detail = message(key, params);
+    }
+}
+/** Bad flags, values or arguments. */
+export class UsageError extends KiriyaError {
+    kind = "usage";
+}
+export class NotFoundError extends KiriyaError {
+    kind = "not-found";
+}
+/** Something already exists where the command would create or move something. */
+export class ConflictError extends KiriyaError {
+    kind = "conflict";
+}
+/** A protected path, or a confirmation that was declined or could not be asked. */
+export class RefusedError extends KiriyaError {
+    kind = "refused";
+}
+/** This machine lacks what the command needs, such as a clipboard program. */
+export class CapabilityUnavailableError extends KiriyaError {
+    kind = "capability-unavailable";
+}
+/** An operation the OS or Node.js reported as failed. */
+export class OperationFailedError extends KiriyaError {
+    kind = "failed";
+}
+export class InterruptedError extends KiriyaError {
+    kind = "interrupted";
+}
+//# sourceMappingURL=errors.js.map

package/dist/src/core/domain/glob.js

@@ -0,0 +1,57 @@
+const GLOB_CHARACTERS = /[*?[{]/;
+const REGEX_SPECIAL = new Set([".", "+", "^", "$", "(", ")", "|", "\\", "/"]);
+export function hasGlob(text) {
+    return GLOB_CHARACTERS.test(text);
+}
+/**
+ * A glob as a RegExp over `/`-separated relative paths, ignoring case, the same on
+ * every OS: `*` and `?` stay within one folder, `**` crosses folders, and `[abc]`,
+ * `[!abc]` and `{ts,tsx}` work as in bash.
+ */
+export function globToRegExp(pattern) {
+    let source = "";
+    let inBraces = false;
+    for (let index = 0; index < pattern.length; index += 1) {
+        const char = pattern.charAt(index);
+        if (char === "*") {
+            if (pattern.charAt(index + 1) === "*") {
+                const slashAfter = pattern.charAt(index + 2) === "/";
+                source += slashAfter ? "(?:.*/)?" : ".*";
+                index += slashAfter ? 2 : 1;
+            }
+            else {
+                source += "[^/]*";
+            }
+        }
+        else if (char === "?") {
+            source += "[^/]";
+        }
+        else if (char === "[") {
+            const close = pattern.indexOf("]", index + 1);
+            if (close < 0) {
+                source += "\\[";
+            }
+            else {
+                const body = pattern.slice(index + 1, close);
+                source += `[${body.startsWith("!") ? `^${body.slice(1)}` : body}]`;
+                index = close;
+            }
+        }
+        else if (char === "{") {
+            inBraces = true;
+            source += "(?:";
+        }
+        else if (char === "}" && inBraces) {
+            inBraces = false;
+            source += ")";
+        }
+        else if (char === "," && inBraces) {
+            source += "|";
+        }
+        else {
+            source += REGEX_SPECIAL.has(char) ? `\\${char}` : char;
+        }
+    }
+    return new RegExp(`^${source}$`, "i");
+}
+//# sourceMappingURL=glob.js.map

package/dist/src/core/domain/global-options.js

@@ -0,0 +1,10 @@
+/** Options every command takes, wherever they appear before `--`. */
+export const GLOBAL_OPTIONS = [
+    { name: "json", short: null, description: "core.option.json" },
+    { name: "no-color", short: null, description: "core.option.no-color" },
+    { name: "no-input", short: null, description: "core.option.no-input" },
+    { name: "debug", short: null, description: "core.option.debug" },
+    { name: "help", short: "h", description: "core.option.help" },
+    { name: "version", short: "V", description: "core.option.version" },
+];
+//# sourceMappingURL=global-options.js.map

package/dist/src/core/domain/input-schema.js

@@ -0,0 +1,54 @@
+import { UsageError } from "./errors.js";
+/** Typed access to raw values, with usage errors that name the option. */
+export class RawReader {
+    raw;
+    constructor(raw) {
+        this.raw = raw;
+    }
+    positional(index) {
+        return this.raw.positionals[index];
+    }
+    positionalsFrom(index) {
+        return this.raw.positionals.slice(index);
+    }
+    flag(name) {
+        return this.raw.options[name] === true;
+    }
+    string(name) {
+        const value = this.raw.options[name];
+        if (value === undefined || value === false)
+            return undefined;
+        if (typeof value !== "string")
+            throw new UsageError("core.usage.expects-value", { option: name });
+        return value;
+    }
+    strings(name) {
+        const value = this.raw.options[name];
+        if (value === undefined || value === false)
+            return [];
+        if (typeof value === "string")
+            return [value];
+        if (Array.isArray(value))
+            return value;
+        throw new UsageError("core.usage.expects-value", { option: name });
+    }
+    choice(name, choices, fallback) {
+        const value = this.string(name);
+        if (value === undefined)
+            return fallback;
+        const match = choices.find((choice) => choice === value);
+        if (match === undefined)
+            throw new UsageError("core.usage.not-a-choice", { option: name, choices: choices.join(", ") });
+        return match;
+    }
+    positiveInteger(name, fallback) {
+        const value = this.string(name);
+        if (value === undefined)
+            return fallback;
+        const number = Number(value);
+        if (!Number.isInteger(number) || number < 1)
+            throw new UsageError("core.usage.not-a-positive-integer", { option: name });
+        return number;
+    }
+}
+//# sourceMappingURL=input-schema.js.map

package/dist/src/core/domain/message.js

@@ -0,0 +1,7 @@
+export function message(key, params = {}) {
+    return { key, params };
+}
+export function isMessage(value) {
+    return typeof value === "object" && value !== null && "key" in value && "params" in value;
+}
+//# sourceMappingURL=message.js.map

package/dist/src/core/domain/module.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=module.js.map

package/dist/src/core/domain/names.js

@@ -0,0 +1,22 @@
+export function isHiddenName(name) {
+    return name.startsWith(".");
+}
+/** Code-point order: unlike localeCompare, the same on every OS and in every locale. */
+export function byCodePoint(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+const FORBIDDEN = /[/\\<>:"|?*]/;
+const RESERVED = /^(con|prn|aux|nul|com[0-9]|lpt[0-9])([.].*)?$/i;
+/** Why a new name would not work on Windows, Linux and macOS alike, or null when it would. */
+export function invalidNameReason(name) {
+    if (name === "" || name === "." || name === "..")
+        return "core.name.empty";
+    if (FORBIDDEN.test(name) || [...name].some((char) => char.charCodeAt(0) < 32))
+        return "core.name.characters";
+    if (/[. ]$/.test(name))
+        return "core.name.trailing";
+    if (RESERVED.test(name))
+        return "core.name.reserved";
+    return null;
+}
+//# sourceMappingURL=names.js.map

package/dist/src/core/domain/ports/clipboard.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=clipboard.js.map

package/dist/src/core/domain/ports/clock.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=clock.js.map

package/dist/src/core/domain/ports/command-catalog.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=command-catalog.js.map

package/dist/src/core/domain/ports/compression.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=compression.js.map