@drhomet/mithaq 0.0.0-stage → 0.1.1

package/dist/mithaq/lock.js

@@ -0,0 +1,329 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+// The lock signs only when a person types back a code shown in a popup, never in
+// this command's own output, so an agent running `mithaq lock` cannot approve it.
+import { execFile } from 'node:child_process';
+import { createPrivateKey, createPublicKey, generateKeyPairSync, randomBytes, randomInt, sign, verify } from 'node:crypto';
+import { createReadStream, createWriteStream } from 'node:fs';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { homedir, hostname } from 'node:os';
+import { join } from 'node:path';
+import { createInterface } from 'node:readline/promises';
+import { receivedLanguage } from './language.js';
+import { Refusal } from './refusal.js';
+import { composeArkan } from './rukn.js';
+/** The first thing anyone reads in `mithaq.lock`. It signs nothing. */
+export const notice = "ميثاق: do not change the vocabulary of defineMithaq (src/mithaq.ts), which is its locales, kinds, rules, targets and root keys, or this file unless the project's developer asked for that change. When the vocabulary must change, tell the developer what and why, then run `mithaq lock` and let them approve it in the popup it shows.";
+export const covenant = "ميثاق: the language changed and is not signed. Only the project's owner may approve a language change. Stop here, tell the owner what you changed and why, and ask them to run `mithaq lock`.";
+const pathOf = (path, key) => typeof key === 'number' ? `${path}[${key}]` : /^[A-Za-z_$][\w$]*$/.test(key) ? (path ? `${path}.${key}` : key) : `${path}[${JSON.stringify(key)}]`;
+// Keys sorted and `undefined` dropped, so one value always writes the same bytes.
+const canonical = (value) => {
+    if (Array.isArray(value))
+        return value.map(canonical);
+    if (value === null || typeof value !== 'object')
+        return value;
+    const record = value;
+    return Object.fromEntries(Object.keys(record)
+        .sort()
+        .filter((key) => record[key] !== undefined)
+        .map((key) => [key, canonical(record[key])]));
+};
+/** Each entry of a record through `pick`; an `undefined` entry stays one, and `canonical` drops it. */
+const each = (record, pick) => Object.fromEntries(Object.entries(record ?? {}).map(([name, value]) => [name, value === undefined ? undefined : pick(value)]));
+/**
+ * What the lock records of the object `defineMithaq` received: the locales, each kind's label, message
+ * and accepted rules, each rule's message and excludes, each target's name and capability, and the root keys.
+ */
+export const vocabularyOf = (received) => {
+    const language = received;
+    // A language with no `arkan` holds its kinds and rules at the root; a lock signed in that shape still reads.
+    const { kinds, rules, targets } = (language.arkan ? composeArkan(language) : language);
+    return canonical({
+        keys: Object.keys(language)
+            .filter((key) => language[key] !== undefined)
+            .sort(),
+        locales: language.locales,
+        kinds: each(kinds, ({ label, message, rules }) => ({ label, message, rules })),
+        rules: each(rules, ({ message, excludes }) => ({ message, excludes })),
+        targets: each(targets, ({ capability }) => capability ?? null),
+    });
+};
+/** The lock as its file holds it: canonical, two-space indented, one trailing newline. */
+export const formatLock = (lock) => `${JSON.stringify(canonical({ ...lock, _notice: notice }), null, 2)}\n`;
+/** Each path at which two canonical languages differ, as a line a person reads. */
+export const changedPaths = ({ was, now, path = '' }) => {
+    if (JSON.stringify(was) === JSON.stringify(now))
+        return [];
+    const name = path || 'the whole language';
+    if (was === undefined)
+        return [`${name} was added`];
+    if (now === undefined)
+        return [`${name} was removed`];
+    const branch = (one) => one !== null && typeof one === 'object';
+    if (!branch(was) || !branch(now) || Array.isArray(was) !== Array.isArray(now)) {
+        return [branch(was) || branch(now) ? `${name} changed` : `${name} was ${JSON.stringify(was)} and is now ${JSON.stringify(now)}`];
+    }
+    const keyed = (one) => one;
+    if (Array.isArray(was)) {
+        const nowList = now;
+        return Array.from({ length: Math.max(was.length, nowList.length) }, (_, index) => changedPaths({ was: was[index], now: nowList[index], path: pathOf(path, index) })).flat();
+    }
+    return [...new Set([...Object.keys(keyed(was)), ...Object.keys(keyed(now))])]
+        .sort()
+        .flatMap((key) => changedPaths({ was: keyed(was)[key], now: keyed(now)[key], path: pathOf(path, key) }));
+};
+const spki = Buffer.from('302a300506032b6570032100', 'hex');
+const publicKeyOf = (key) => createPublicKey(key).export({ type: 'spki', format: 'der' }).subarray(spki.length).toString('base64');
+const keyFromPublic = (publicKey) => createPublicKey({ key: Buffer.concat([spki, Buffer.from(publicKey, 'base64')]), format: 'der', type: 'spki' });
+// `canonical` drops a missing `previous`, so a seal without one signs the same bytes.
+const signed = (language, project, signers, previous) => Buffer.from(JSON.stringify(canonical({ language, project, signers, previous })));
+// Checked before it names a file.
+const projectId = /^[0-9a-f]{32}$/;
+// Printed into the popup, so short and free of control characters.
+const labelled = (label) => typeof label === 'string' && label.length <= 64 && !/[\p{Cc}\p{Cf}]/u.test(label);
+const labelRule = 'is longer than 64 characters or holds a control character';
+/**
+ * Signs a canonical language with this machine's key, over `base`'s project and
+ * signers, adding this machine to the signers when it is not one of them yet.
+ */
+export const sealLanguage = ({ language, key, base, label = hostname(), }) => {
+    const project = base?.project ?? randomBytes(16).toString('hex');
+    const publicKey = publicKeyOf(key);
+    const signers = base?.signers.some((one) => one.publicKey === publicKey)
+        ? base.signers
+        : [...(base?.signers ?? []), { publicKey, label, addedAt: new Date().toISOString() }];
+    if (!signers.every((one) => labelled(one.label)))
+        throw new Refusal(`A signer's label ${labelRule}, so nothing is signed.`);
+    const signature = sign(null, signed(language, project, signers), key).toString('base64');
+    return { language, seal: { project, signers, signature, sealedAt: new Date().toISOString() } };
+};
+// A key a lock never holds is one a forgery could pad itself with.
+const unreadable = (lock) => {
+    if (lock === null || typeof lock !== 'object' || Array.isArray(lock))
+        return 'is not a JSON object';
+    if (Object.keys(lock).some((key) => !['_notice', 'language', 'seal'].includes(key)))
+        return 'holds keys other than _notice, language and seal';
+    const seal = lock.seal;
+    const signers = seal && typeof seal === 'object' && Array.isArray(seal.signers) ? seal.signers : [];
+    if (signers.some((one) => !labelled(one?.label)))
+        return `names a signer whose label ${labelRule}`;
+    return undefined;
+};
+/** Where a lock stands against the current language: the paths that changed, and its seal's state. */
+export const verifyLock = (language, lock) => {
+    const changed = changedPaths({ was: lock.language, now: language });
+    const seal = lock.seal;
+    if (unreadable(lock))
+        return { changed, seal: 'invalid' };
+    if (seal === 'pending')
+        return { changed, seal: 'pending' };
+    if (seal === undefined || seal === null)
+        return { changed, seal: 'missing' };
+    const { project, signers, signature, previous } = seal;
+    if (typeof project !== 'string' || !Array.isArray(signers) || typeof signature !== 'string' || !['string', 'undefined'].includes(typeof previous)) {
+        return { changed, seal: 'invalid' };
+    }
+    const payload = signed(lock.language, project, signers, previous);
+    const valid = signers.some((one) => {
+        try {
+            return verify(null, payload, keyFromPublic(String(one.publicKey)), Buffer.from(signature, 'base64'));
+        }
+        catch {
+            return false;
+        }
+    });
+    return { changed, seal: valid ? 'signed' : 'invalid' };
+};
+/** `mithaq lock --check`. A project with no `mithaq.lock` passes with one notice; one with a lock is held to it. */
+export const checkLock = (language, text) => {
+    if (text === undefined) {
+        return { code: 0, message: "No mithaq.lock: this project's language is not locked. Run `mithaq lock` to lock it." };
+    }
+    let lock;
+    try {
+        lock = JSON.parse(text);
+    }
+    catch {
+        return { code: 1, message: `mithaq.lock is not JSON, so nobody's signature over it can be read.\n\n${covenant}` };
+    }
+    const why = unreadable(lock);
+    if (why)
+        return { code: 1, message: `mithaq.lock ${why}, so nobody's signature over it is read.\n\n${covenant}` };
+    const { changed, seal } = verifyLock(language, lock);
+    if (changed.length) {
+        return { code: 1, message: `The language is not the one mithaq.lock records:\n${changed.map((line) => `  - ${line}`).join('\n')}\n\n${covenant}` };
+    }
+    // Nobody has signed a pending lock, so it fails like a missing seal.
+    if (seal === 'pending') {
+        return {
+            code: 1,
+            message: 'Pending: mithaq.lock records this language and nobody has signed it yet. Run `mithaq lock`, and the project\'s owner approves it in the popup it shows.',
+        };
+    }
+    if (seal !== 'signed') {
+        return { code: 1, message: `mithaq.lock's seal is ${seal === 'missing' ? 'missing' : 'not a signature of the language it records'}.\n\n${covenant}` };
+    }
+    return { code: 0, message: 'mithaq.lock is signed, and the language is the one it records.' };
+};
+/** Runs a program, feeding `input` on stdin, and answers its stdout, or nothing where it failed. */
+const ask = (program, argv, input) => new Promise((resolve) => {
+    const child = execFile(program, argv, { timeout: 5 * 60_000 }, (error, stdout) => resolve(error ? undefined : stdout.trim()));
+    child.stdin?.end(input ?? '');
+});
+/** Whether a program answers on this machine's PATH. */
+const has = (program) => ask(process.platform === 'win32' ? 'where' : 'which', [program]).then((found) => Boolean(found));
+// Opened directly, so a piped or scripted stdin never answers it.
+const terminal = async (summary, code) => {
+    const [inPath, outPath] = process.platform === 'win32' ? ['CONIN$', 'CONOUT$'] : ['/dev/tty', '/dev/tty'];
+    const opened = await new Promise((resolve) => {
+        const input = createReadStream(inPath);
+        input.once('error', () => resolve(undefined));
+        input.once('open', () => {
+            const output = createWriteStream(outPath);
+            output.once('error', () => resolve(undefined));
+            output.once('open', () => resolve([input, output]));
+        });
+    });
+    if (!opened)
+        return undefined;
+    const [input, output] = opened;
+    const line = createInterface({ input, output, terminal: true });
+    try {
+        return await line.question(`${summary}\n\nType ${code} to approve, or anything else to cancel: `);
+    }
+    finally {
+        line.close();
+        input.destroy();
+        output.end();
+    }
+};
+const appleText = (text) => `"${text.replaceAll('\\', '\\\\').replaceAll('"', '\\"')}"`;
+const powershellText = (text) => `'${text.replaceAll("'", "''")}'`;
+// The script reaches `osascript` and PowerShell on stdin, so the code is in no command
+// line another process can list. `zenity` and `kdialog` take it as an argument.
+export const popup = async (summary, code) => {
+    const text = `${summary}\n\nType ${code} to approve.`;
+    if (process.platform === 'darwin') {
+        const script = `text returned of (display dialog ${appleText(text)} with title "mithaq.lock" default answer "" buttons {"Cancel", "Approve"} default button "Approve")`;
+        const answer = await ask('osascript', ['-'], script);
+        if (answer !== undefined)
+            return answer;
+    }
+    else if (process.platform === 'win32') {
+        const script = `Add-Type -AssemblyName Microsoft.VisualBasic; [Microsoft.VisualBasic.Interaction]::InputBox(${powershellText(text)}, 'mithaq.lock', '')`;
+        const answer = await ask('powershell', ['-NoProfile', '-NonInteractive', '-Command', '-'], script);
+        if (answer !== undefined)
+            return answer;
+    }
+    else if (process.env.DISPLAY || process.env.WAYLAND_DISPLAY) {
+        if (await has('zenity'))
+            return ask('zenity', ['--entry', '--title=mithaq.lock', `--text=${text}`]);
+        if (await has('kdialog'))
+            return ask('kdialog', ['--title', 'mithaq.lock', '--inputbox', text]);
+    }
+    return terminal(summary, code);
+};
+/** Where this machine keeps its signing keys, one file per project, outside every repository. */
+const keysHome = () => process.platform === 'win32' && process.env.APPDATA ? join(process.env.APPDATA, 'mithaq', 'keys') : join(homedir(), '.mithaq', 'keys');
+/** This machine's key for a project: read, or made and kept (mode 0600) on first use. */
+const machineKey = async (keys, project) => {
+    if (!projectId.test(project))
+        throw new Refusal(`mithaq.lock names the project "${project}", which is not a project id, so no key file is read for it.`);
+    const file = join(keys, `${project}.key`);
+    const pem = await readFile(file, 'utf8').catch((error) => {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw error;
+    });
+    if (pem)
+        return createPrivateKey(pem);
+    const { privateKey } = generateKeyPairSync('ed25519');
+    await mkdir(keys, { recursive: true, mode: 0o700 });
+    await writeFile(file, privateKey.export({ type: 'pkcs8', format: 'pem' }), { mode: 0o600, flag: 'wx' });
+    return privateKey;
+};
+// Never stops the command it runs before: `mithaq generate --check` is where an unsigned change fails.
+export const warnLock = async (project) => {
+    try {
+        const { defineKayan } = (await import(__rewriteRelativeImportExtension(new URL('src/mithaq.ts', project).href)));
+        const received = receivedLanguage(defineKayan);
+        if (received === undefined)
+            return;
+        const text = await readFile(new URL('mithaq.lock', project), 'utf8').catch(() => undefined);
+        const { code, message } = checkLock(vocabularyOf(received), text);
+        if (code || message.startsWith('Pending:'))
+            console.error(`${message}\n`);
+    }
+    catch {
+        // The command itself reports a project that does not load.
+    }
+};
+const usage = 'Usage: mithaq lock | mithaq lock --check';
+/** `mithaq lock` and `mithaq lock --check`, run from the project root. `approve` and `keys` are for tests. */
+export const run = async ({ project, noun, flags, approve = popup, keys = keysHome(), }) => {
+    const check = flags.includes('--check');
+    if (noun !== undefined || flags.some((flag) => flag !== '--check')) {
+        console.error(usage);
+        return 1;
+    }
+    const { defineKayan } = (await import(__rewriteRelativeImportExtension(new URL('src/mithaq.ts', project).href)));
+    const received = receivedLanguage(defineKayan);
+    if (received === undefined) {
+        throw new Refusal('src/mithaq.ts exports no `defineKayan` returned by `defineMithaq`, so there is no language to lock. Export it as `export const { defineKayan, ... } = defineMithaq({ ... })`.');
+    }
+    const language = vocabularyOf(received);
+    const file = new URL('mithaq.lock', project);
+    const text = await readFile(file, 'utf8').catch((error) => {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw error;
+    });
+    if (check) {
+        const { code, message } = checkLock(language, text);
+        if (code)
+            console.error(message);
+        else
+            console.log(message);
+        return code;
+    }
+    const lock = text === undefined ? undefined : JSON.parse(text);
+    const why = text === undefined ? undefined : unreadable(lock);
+    if (why)
+        throw new Refusal(`mithaq.lock ${why}, so it is not read. Restore it from its last commit, then run \`mithaq lock\` again.`);
+    const seal = lock !== undefined && lock.seal !== 'pending' && lock.seal ? lock.seal : undefined;
+    // A seal that does not verify is dropped whole, so no name it lists is signed by the next approval.
+    const valid = seal !== undefined && verifyLock(lock.language, lock).seal === 'signed';
+    const id = valid ? seal.project : randomBytes(16).toString('hex');
+    const signers = valid ? seal.signers : [];
+    const key = await machineKey(keys, id);
+    const label = hostname();
+    if (!labelled(label))
+        throw new Refusal(`This machine's name, which labels it in mithaq.lock, ${labelRule}, so nothing is signed.`);
+    const newSigner = !signers.some((one) => one.publicKey === publicKeyOf(key));
+    const changed = changedPaths({ was: lock?.language, now: language });
+    if (valid && !changed.length && !newSigner) {
+        console.log('mithaq.lock is signed, and the language is the one it records. Nothing to sign.');
+        return 0;
+    }
+    const summary = [
+        changed.length ? `These changes to the language:\n${changed.map((line) => `  - ${line}`).join('\n')}` : 'The language is the one mithaq.lock records.',
+        seal && !valid ? "mithaq.lock's seal does not verify, so its signers are dropped and the lock starts over as a new project." : '',
+        newSigner ? `This machine, ${label} (key ${publicKeyOf(key)}), signs this project's lock for the first time.` : '',
+    ]
+        .filter(Boolean)
+        .join('\n\n');
+    console.log(`${summary}\n\nWaiting for a person to approve in the popup on this machine's screen.`);
+    const code = randomInt(10, 100);
+    const answer = await approve(summary, code);
+    if (answer?.trim() !== String(code))
+        throw new Refusal('Not approved, so nothing was signed.');
+    await writeFile(file, formatLock(sealLanguage({ language, key, base: { project: id, signers }, label })));
+    console.log(`Approved. Wrote mithaq.lock, signed by ${label}.`);
+    return 0;
+};

package/dist/mithaq/messages.d.ts

@@ -0,0 +1,55 @@
+import { defaultFields } from '../base/fields.ts';
+import { type LabelFunction, type Localized, type ResolvedKayan } from './types.ts';
+import type { Language } from './language.ts';
+/** What one key resolves to: a record per locale, which is checked, or a function or string, which nothing can verify. */
+export type Copy = Localized | LabelFunction | string;
+/** One generated file: the keys one scope claims, and where its file goes. */
+export type MessageScope = {
+    name: string;
+    /** The path the scope named, if it named one, in place of the default. */
+    out?: string;
+    keys: Record<string, Copy>;
+    /** The `mithaq` scope key each seeded key is written from, so a run tells an entry nobody edited from one a person wrote. */
+    seeds?: Record<string, string>;
+};
+/** The shape a project's own resolver returns, keyed by the shipped copy's own keys, so a forgotten kind is a type error. */
+export type ProjectMessages<L extends Language = Language> = {
+    kinds: {
+        [Name in keyof L['kinds']]: string;
+    };
+    fields: {
+        [Name in keyof typeof defaultFields]: string;
+    };
+    globalType: string;
+};
+/**
+ * The project's resolver. Its parameter is typed `never`, so a project annotates it with any
+ * argument; mithaq calls it with nothing and uses what comes back.
+ */
+export type MessagesResolver<L extends Language = Language> = (context: never) => ProjectMessages<L>;
+/** Every scope of one build, with the keys two scopes both claim named. */
+export type MessageRegistry = {
+    /** The locales the language declared, in the order it declared them. */
+    locales: readonly string[];
+    scopes: readonly MessageScope[];
+    /** One entry per key more than one scope claims, naming each claim. */
+    collisions: Record<string, readonly string[]>;
+    /** Whether the project handed `buildAsas` a resolver at all. */
+    resolved: boolean;
+    /** Every localized field of the build, so `--check` can find rows written before a locale was added. */
+    localized: readonly {
+        kayan: string;
+        store: string;
+        field: string;
+        sort: string | undefined;
+    }[];
+};
+/**
+ * The scopes one build writes, and the keys two scopes both claim. Narrowest first: a field's
+ * `label`, the kayan's `messages`, the project's resolver, then the shipped copy.
+ */
+export declare const messagesOf: ({ language, kayanList, resolver, }: {
+    language: Language;
+    kayanList: readonly ResolvedKayan[];
+    resolver?: MessagesResolver;
+}) => MessageRegistry;

package/dist/mithaq/messages.js

@@ -0,0 +1,106 @@
+import { defaultFields, globalTypeLabel } from '../base/fields.js';
+import { sortableFields } from './types.js';
+import { providerOf } from '../base/rules.js';
+// One refusal sentence per rule and per kind, which every per-field key is seeded
+// from, so a new locale costs one sentence per rule and kind, not one per field.
+const floorKeys = (language) => ({
+    ...Object.fromEntries(Object.entries(language.kinds).map(([name, kind]) => [`kinds.${name}`, kind.label])),
+    ...Object.fromEntries(Object.entries(defaultFields)
+        .filter(([, field]) => field.label)
+        .map(([name, field]) => [`fields.${name}`, field.label])),
+    globalType: globalTypeLabel,
+    ...Object.fromEntries(Object.entries(language.rules)
+        .filter(([, rule]) => rule.message)
+        .map(([name, rule]) => [`rules.${name}`, rule.message])),
+    ...Object.fromEntries(Object.entries(language.kinds).map(([name, kind]) => [`kinds.${name}.invalid`, kind.message])),
+});
+/**
+ * The scopes one build writes, and the keys two scopes both claim. Narrowest first: a field's
+ * `label`, the kayan's `messages`, the project's resolver, then the shipped copy.
+ */
+export const messagesOf = ({ language, kayanList, resolver, }) => {
+    const scopes = [{ name: 'mithaq', keys: floorKeys(language) }];
+    const collisions = {};
+    for (const kayan of kayanList) {
+        // No prototype, so no field or operation name finds an inherited answer.
+        const keys = Object.create(null);
+        const seeds = Object.create(null);
+        const claims = Object.create(null);
+        const claim = (key, from, copy) => {
+            ;
+            (claims[key] ??= []).push(from);
+            // The field wins where both claim one, which is the narrowest-first rule.
+            keys[key] ??= copy;
+        };
+        for (const [name, field] of Object.entries(kayan.fields)) {
+            if (field.description)
+                claim(`${name}.description`, `field "${name}" description`, field.description);
+            if (field.placeholder)
+                claim(`${name}.placeholder`, `field "${name}" placeholder`, field.placeholder);
+            // A label mithaq ships is the same object as the floor's, so only a label this kayan declared is its own claim.
+            if (!field.label || field.label === defaultFields[name]?.label || field.label === globalTypeLabel)
+                continue;
+            claim(name, `field "${name}" label`, field.label);
+        }
+        // Claimed once per field however many screens ask for it.
+        for (const [name, operation] of Object.entries(kayan.operations)) {
+            const fields = Object.entries(operation.targets ?? {}).flatMap(([screen, block]) => language.targets[screen]?.capability === 'screen' ? Object.entries(block?.fields ?? {}) : []);
+            for (const [field, declared] of fields) {
+                const key = `operations.${name}.${field}`;
+                if (declared.label && !(key in keys))
+                    claim(key, `operation "${name}" field "${field}" label`, declared.label);
+            }
+        }
+        for (const [key, copy] of Object.entries((kayan.messages ?? {}))) {
+            claim(key, 'messages', copy);
+        }
+        // A floor rather than a claim, so a kayan's `messages` may override a seeded key
+        // without a `--check` collision.
+        for (const [name, field] of Object.entries(kayan.fields)) {
+            // A field whose shape a target replaced gets none: mithaq built no shape for it. Neither
+            // does one the client supplies on neither write, since no refusal can name it.
+            if (field.targets?.[kayan.schema] || (field.name !== 'id' && providerOf(field, 'create') !== 'client' && providerOf(field, 'update') !== 'client'))
+                continue;
+            const seed = (key, from, message) => {
+                if (key in keys)
+                    return;
+                keys[key] = message;
+                seeds[key] = from;
+            };
+            seed(`${name}.invalid`, `kinds.${field.kind}.invalid`, language.kinds[field.kind].message);
+            for (const rule of Object.keys(field.rules ?? {})) {
+                // Only a rule that can refuse a value: any other key is one no refusal asks for and
+                // every locale pays a translator for.
+                const message = language.rules[rule].message;
+                if (message)
+                    seed(`${name}.${rule}`, `rules.${rule}`, message);
+            }
+        }
+        for (const [key, from] of Object.entries(claims)) {
+            if (from.length > 1)
+                collisions[`${kayan.name}.${key}`] = from;
+        }
+        // A kayan named `mithaq` or `project` is refused at `resolve`, since the generator finds these scopes by name.
+        if (Object.keys(keys).length)
+            scopes.push({ name: kayan.name, out: kayan.out, keys, seeds });
+    }
+    if (resolver) {
+        const returned = resolver();
+        const keys = { globalType: returned.globalType };
+        for (const [name, copy] of Object.entries(returned.kinds ?? {}))
+            keys[`kinds.${name}`] = copy;
+        for (const [name, copy] of Object.entries(returned.fields ?? {}))
+            keys[`fields.${name}`] = copy;
+        scopes.push({ name: 'project', keys });
+    }
+    const localized = kayanList.flatMap((kayan) => Object.values(kayan.fields)
+        .filter((field) => field.rules?.localized)
+        .map((field) => ({
+        kayan: kayan.name,
+        store: kayan.store,
+        field: field.name,
+        // `undefined` where no field can sort a page, and the scan refuses that by name.
+        sort: sortableFields(kayan)[0],
+    })));
+    return { locales: language.locales ?? [], scopes, collisions, resolved: !!resolver, localized };
+};

package/dist/mithaq/refusal.d.ts

@@ -0,0 +1,6 @@
+/**
+ * A refusal a person is meant to read: the CLI prints its message alone, and
+ * rethrows every other error with its stack.
+ */
+export declare class Refusal extends Error {
+}

package/dist/mithaq/refusal.js

@@ -0,0 +1,6 @@
+/**
+ * A refusal a person is meant to read: the CLI prints its message alone, and
+ * rethrows every other error with its stack.
+ */
+export class Refusal extends Error {
+}

package/dist/mithaq/resolve.d.ts

@@ -0,0 +1,10 @@
+import { type Kayan, type ResolvedKayan } from './types.ts';
+import { type Language } from './language.ts';
+export declare const snakeCase: (name: string) => string;
+export declare const versionsTableOf: (kayan: {
+    table: string;
+}) => string;
+/** The default indexes a `unique` rule makes, which a store may build as the column's own constraint. */
+export declare const uniqueRuleIndexes: WeakSet<object>;
+export declare const isPlainIdentifier: (value: string) => boolean;
+export declare const resolve: (kayanList: readonly Kayan[], language: Language) => ResolvedKayan[];