@drhomet/mithaq 0.0.0-stage → 0.2.0

package/dist/asas/cli/mithaq.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/asas/cli/mithaq.js

@@ -0,0 +1,177 @@
+#!/usr/bin/env node
+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;
+};
+// Each generator is imported when its word is asked for, so `better-auth/db` loads
+// only for `generate auth` and the `generate --check` sweep.
+import { realpathSync } from 'node:fs';
+import * as modules from 'node:module';
+import { pathToFileURL } from 'node:url';
+import { Refusal } from '../../mithaq/refusal.js';
+const verbs = ['eject', 'generate', 'lock', 'migrate', 'screens', 'upgrade'];
+const nouns = ['auth', 'messages', 'screens'];
+const usage = 'Usage: mithaq generate auth [--check] | mithaq generate messages [--check] [--no-data-scan] | mithaq generate screens [--check] | mithaq generate --check | mithaq lock [--check] | mithaq migrate [--check] [--name <slug>] | mithaq screens | mithaq upgrade --check | mithaq eject <item> | mithaq eject --prune | mithaq <target> <command> [--check]';
+// Run as a command, not imported. The bin is a symlink, so compare real paths.
+if (process.argv[1] && realpathSync(process.argv[1]) === import.meta.filename) {
+    // A project's sources may import each other with no extension, as Vite, Bun and drizzle-kit
+    // resolve them and Node does not, so a relative import that names no file is tried as `.ts`,
+    // then as a folder's `index.ts`. Only after Node's own resolution failed, never under node_modules.
+    modules.registerHooks?.({
+        resolve: (specifier, context, next) => {
+            try {
+                return next(specifier, context);
+            }
+            catch (error) {
+                const code = error.code;
+                if (!/^\.\.?\//.test(specifier) || context.parentURL?.includes('/node_modules/') || (code !== 'ERR_MODULE_NOT_FOUND' && code !== 'ERR_UNSUPPORTED_DIR_IMPORT'))
+                    throw error;
+                for (const tail of ['.ts', '/index.ts']) {
+                    try {
+                        return next(`${specifier}${tail}`, context);
+                    }
+                    catch { }
+                }
+                throw error;
+            }
+        },
+    });
+    try {
+        const [, , verb, noun, ...rest] = process.argv;
+        // Before anything reads the project: outside one there is no `src/asas.ts` to import.
+        if (verb === '--help' || verb === '-h') {
+            console.log(usage);
+            process.exit(0);
+        }
+        // `generate --check` takes no noun, so the word in the noun's place is a flag.
+        const flags = noun?.startsWith('--') ? [noun, ...rest] : rest;
+        const sweeping = verb === 'generate' && flags.includes('--check') && !nouns.includes(noun ?? '');
+        // `migrate` is a word of the bin's own wherever it stands first, so it takes flags
+        // and never a second word; a target named `migrate` is reached by no spelling.
+        const misplaced = (verb === 'migrate' || verb === 'upgrade') && noun !== undefined && !noun.startsWith('--');
+        const unchecked = verb === 'upgrade' && !flags.includes('--check');
+        // `eject` takes one item or `--prune`, never both and never neither.
+        const ejecting = noun !== undefined && !noun.startsWith('--');
+        const unejected = verb === 'eject' && (ejecting ? flags.length > 0 : flags.join(' ') !== '--prune');
+        if (verb === undefined || misplaced || unchecked || unejected || (verb === 'generate' && !(sweeping || nouns.includes(noun ?? '')))) {
+            console.error(usage);
+            process.exit(1);
+        }
+        const project = pathToFileURL(`${process.cwd()}/`);
+        const check = flags.includes('--check');
+        // The project saying it has no database to scan, which a check otherwise refuses to pass without.
+        const scan = !flags.includes('--no-data-scan');
+        const auth = async (checking) => (await import('../../auth/better-auth/generate.js')).run(project, checking);
+        const messages = async () => (await import('../../mithaq/generate-messages.js')).run({ project, check, dataScan: scan });
+        const screens = async () => (await import('../../screen/generate.js')).run(project, check);
+        const upgrade = async () => (await import('./upgrade.js')).run(project);
+        const lock = async (word, words) => (await import('../../mithaq/lock.js')).run({ project, noun: word, flags: words });
+        // Imported only where a target's command was asked for: `generate auth` runs against
+        // a project whose `src/asas.ts` may not import at all.
+        const asasOf = async () => (await import(__rewriteRelativeImportExtension(new URL('src/asas.ts', project).href))).asas;
+        // `Object.hasOwn`: a typed word would otherwise reach `Object.prototype`, and
+        // `mithaq drizzle constructor` would call `Object`.
+        const commandsOf = (asas, name) => (Object.hasOwn(asas.targets, name) ? asas.targets[name]?.commands : undefined) ?? {};
+        const commandIn = (commands, name) => Object.hasOwn(commands, name) ? commands[name] : undefined;
+        const everyCommand = (asas) => Object.entries(asas.targets).flatMap(([name, target]) => Object.entries(target?.commands ?? {}).map(([command, one]) => [`${name} ${command}`, one]));
+        const stopped = (name, code) => {
+            console.error(`\`mithaq ${name} --check\` answered ${code}, so the sweep stopped there.`);
+            process.exit(code);
+        };
+        // Every command but the lock's own and the sweep shows an unsigned language change first.
+        if (verb !== 'lock' && !(verb === 'generate' && sweeping))
+            await (await import('../../mithaq/lock.js')).warnLock(project);
+        if (verb === 'generate' && sweeping) {
+            // Stops at the first non-zero, so a pipeline reads which check failed. The lock goes first,
+            // and `migrate` before anything that reads rows, so an unmigrated database stops it by name.
+            const step = async (name, one) => {
+                const code = await one();
+                if (code)
+                    stopped(name, code);
+            };
+            await step('lock', () => lock(undefined, ['--check']));
+            await step('generate auth', () => auth(true));
+            // A command with no check to make answers 0 for the flag it does not know.
+            const asas = await asasOf();
+            const commands = everyCommand(asas);
+            const migrates = commands.filter(([name]) => name.endsWith(' migrate'));
+            const others = commands.filter(([name]) => !name.endsWith(' migrate'));
+            for (const [name, one] of migrates)
+                await step(name, () => one({ asas, flags }));
+            await step('generate messages', messages);
+            await step('generate screens', screens);
+            for (const [name, one] of others)
+                await step(name, () => one({ asas, flags }));
+            // A report, never a gate: a copy that differs from the registry is a file the project owns.
+            await upgrade().catch((error) => console.error(`upgrade --check could not read the copies: ${error.message}`));
+        }
+        else if (verb === 'lock') {
+            const code = await lock(noun?.startsWith('--') ? undefined : noun, flags);
+            if (code)
+                process.exit(code);
+        }
+        else if (verb === 'eject') {
+            const { eject, prune } = await import('./upgrade.js');
+            const code = ejecting ? await eject(project, noun) : await prune(project);
+            if (code)
+                process.exit(code);
+        }
+        else if (verb === 'upgrade') {
+            const code = await upgrade();
+            if (code)
+                process.exit(code);
+        }
+        else if (verb === 'generate') {
+            const code = await (noun === 'messages' ? messages() : noun === 'screens' ? screens() : auth(check));
+            if (code)
+                process.exit(code);
+        }
+        else if (verb === 'screens') {
+            const { studioText, studioTree } = await import('../../screen/studio.js');
+            const targets = (await asasOf()).targets;
+            const trees = Object.entries(targets).flatMap(([name, target]) => (target?.capability === 'screen' ? [studioText(studioTree(name, target.client))] : []));
+            console.log(trees.join('\n\n'));
+        }
+        else {
+            const asas = await asasOf();
+            // Two stores that both declare `migrate` cannot be told apart by the bare word, so it is refused.
+            const aliased = verb === 'migrate';
+            const declared = aliased ? Object.keys(asas.targets).filter((name) => commandsOf(asas, name).migrate) : [];
+            if (aliased && declared.length === 0) {
+                throw new Refusal('No target of this language declares a `migrate` command, and that is what `mithaq migrate` runs. Name a store that declares one in `targets`, or migrate that store with its own tool.');
+            }
+            if (aliased && declared.length > 1) {
+                throw new Refusal(`${declared.join(', ')} each declare a \`migrate\` command, so \`mithaq migrate\` cannot say which one to run. Name the target: ${declared.map((name) => `\`mithaq ${name} migrate\``).join(', ')}.`);
+            }
+            const target = aliased ? declared[0] : verb;
+            const command = aliased ? 'migrate' : noun;
+            if (!Object.hasOwn(asas.targets, target)) {
+                throw new Refusal(`"${verb}" is neither a command of mithaq nor a target of this language. The commands are ${verbs.join(' and ')}; the targets are ${Object.keys(asas.targets).join(', ')}.`);
+            }
+            if (command === undefined || command.startsWith('--')) {
+                console.error(usage);
+                process.exit(1);
+            }
+            const one = commandIn(commandsOf(asas, target), command);
+            if (!one) {
+                const has = Object.keys(commandsOf(asas, target)).map((name) => `\`${name}\``);
+                throw new Refusal(`Target "${target}" declares no \`${command}\` command. It declares ${has.length ? has.join(', ') : 'none at all'}.`);
+            }
+            const code = await one({ asas, flags });
+            if (code)
+                process.exit(code);
+        }
+    }
+    catch (error) {
+        // Anything that is not a refusal is rethrown, so Node prints its stack, which is the whole
+        // diagnosis of a project's `src/asas.ts` failing to import.
+        if (!(error instanceof Refusal))
+            throw error;
+        console.error(error.message);
+        process.exit(1);
+    }
+}

package/dist/asas/cli/upgrade.d.ts

@@ -0,0 +1,33 @@
+/** The hash of a copy `shadcn add` made, without its marker and the leading comments it dropped. */
+export declare const hashOf: (text: string) => string;
+/** A held file's state against the package's text of it, read as `upgrade --check` reads it. */
+export declare const stateOf: (text: string, source: string) => 'up to date' | 'up to date, edited' | 'differs' | 'differs, edited' | 'unknown';
+export type Copied = {
+    /** The file, relative to the project, or the target or package path that resolved outside it. */
+    path: string;
+    state: 'up to date' | 'up to date, edited' | 'differs' | 'differs, edited' | 'unknown' | 'outside' | 'removed';
+    /** The version or commit the file's marker names, when it carries one. */
+    from?: string;
+    /** The installed mithaq-admin's version. */
+    to?: string;
+    /** The item of a file the project always holds, which it never deletes: it ejects the item again instead. */
+    item?: string;
+};
+/**
+ * Every package file the project holds at its target, ejected or always the project's, with its state. Reads only;
+ * a path that climbs out of the project or the package is listed as outside, never followed.
+ */
+export declare const upgradeCheck: (project: URL) => Promise<Copied[] | undefined>;
+/** `mithaq upgrade --check`: one line per file the project holds, and 1 where any differs. It never writes. */
+export declare const run: (project: URL) => Promise<number>;
+/**
+ * `mithaq eject <item>`: writes the item's own files where the project keeps them, each byte for byte with a marker,
+ * and never over a file already there. It copies no other item and installs nothing: the package serves every
+ * sibling, so it only names a primitive or an npm package the project lacks.
+ */
+export declare const eject: (project: URL, name: string) => Promise<number>;
+/**
+ * `mithaq eject --prune`: deletes every marked file in the folders pieces are ejected into whose text still hashes
+ * to its marker, so the package draws it again. Never an edited, unmarked or `~/` file.
+ */
+export declare const prune: (project: URL) => Promise<number>;

package/dist/asas/cli/upgrade.js

@@ -0,0 +1,256 @@
+import { createHash } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import { mkdir, readdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
+// The last line of every ejected file: the version (or, for a copy `shadcn add` made, the commit) it came from and the
+// hash of the file above. Trailing, because `shadcn add` dropped a file's leading comments only.
+const marker = /\n\/\/ mithaq-admin (\S+) ([0-9a-f]{64})\n?$/;
+// What `shadcn add` dropped, so a hash is the same over the package's text and a copy it made.
+const leading = /^(?:\s+|\/\/[^\n]*|\/\*[\s\S]*?\*\/)*/;
+/** What an eject writes above the marker: the file's text, ending in a newline. */
+const bodyOf = (text) => {
+    const body = text.replace(marker, '\n');
+    return body.endsWith('\n') ? body : `${body}\n`;
+};
+const sha = (text) => createHash('sha256').update(text).digest('hex');
+/** The hash of a copy `shadcn add` made, without its marker and the leading comments it dropped. */
+export const hashOf = (text) => sha(bodyOf(text).replace(leading, ''));
+/**
+ * The hash a marker from `from` holds: of the whole text above it for an eject, which writes byte for byte, so an edit
+ * to a leading pragma is an edit; without leading comments only for a copy made at a commit, as `shadcn add` wrote it.
+ */
+const madeByShadcn = (from) => /^(?:[0-9a-f]{40}|unknown)$/.test(from);
+const hashFrom = (from) => (text) => (madeByShadcn(from) ? hashOf(text) : sha(bodyOf(text)));
+/** A held file's state against the package's text of it, read as `upgrade --check` reads it. */
+export const stateOf = (text, source) => {
+    const [, from, hash] = marker.exec(text) ?? [];
+    if (!hash)
+        return 'unknown';
+    const hashed = hashFrom(from);
+    return `${hash !== hashed(source) ? 'differs' : 'up to date'}${hash !== hashed(text) ? ', edited' : ''}`;
+};
+/** The `mithaq-admin` the project installed: its folder, its version and its items, or none. */
+const installedOf = async (project) => {
+    let manifest;
+    try {
+        manifest = pathToFileURL(createRequire(new URL('package.json', project)).resolve('mithaq-admin/package.json'));
+    }
+    catch {
+        return undefined;
+    }
+    const root = new URL('./', manifest);
+    const { version } = JSON.parse(await readFile(manifest, 'utf8'));
+    const { items } = JSON.parse(await readFile(new URL('registry.json', root), 'utf8'));
+    return { root, version, items };
+};
+// `new URL` resolves every `..`, encoded or not, so a prefix is the whole test.
+const within = (url, folder) => url.href.startsWith(folder.href);
+/** Where the project keeps each target: `@<alias>/…` through `components.json`, `~/…` from the project's root. */
+const targetsOf = async (project) => {
+    const components = JSON.parse(await readFile(new URL('components.json', project), 'utf8'));
+    const src = existsSync(new URL('src/', project)) ? 'src/' : '';
+    return (target) => {
+        if (target.startsWith('~/'))
+            return target.slice(2);
+        const [, alias = '', rest] = /^@([^/]+)\/(.+)$/.exec(target) ?? [];
+        // shadcn resolves an alias through the app's tsconfig `paths`; this reads `@/` as `src/`
+        // when the project has one and as its root otherwise, shadcn's own fallback.
+        const at = components.aliases?.[alias];
+        return at?.startsWith('@/') ? `${src}${at.slice(2)}/${rest}` : undefined;
+    };
+};
+const folderOf = (path) => path.slice(0, path.lastIndexOf('/') + 1);
+/** The folders a piece the package serves (`registry/<file>`) is ejected into: what `eject --prune` sweeps. */
+const ejectedFolders = (items, pathOf) => new Set(items.flatMap((item) => item.files.filter((file) => !file.path.slice('registry/'.length).includes('/')).flatMap((file) => { const path = pathOf(file.target); return path ? folderOf(path) : []; })));
+/**
+ * Every package file the project holds at its target, ejected or always the project's, with its state. Reads only;
+ * a path that climbs out of the project or the package is listed as outside, never followed.
+ */
+export const upgradeCheck = async (project) => {
+    const pathOf = await targetsOf(project);
+    const installed = await installedOf(project);
+    if (!installed)
+        return undefined;
+    const copied = [];
+    /** Every path an item names, held or not, and the folders they sit in, which a file no item names any more is looked for in. */
+    const named = new Set();
+    const folders = new Set();
+    const ejected = ejectedFolders(installed.items, pathOf);
+    for (const { name, files } of installed.items) {
+        for (const file of files) {
+            const source = new URL(file.path, installed.root);
+            const path = pathOf(file.target);
+            if (!within(source, installed.root)) {
+                copied.push({ path: file.path, state: 'outside' });
+                continue;
+            }
+            if (path && !within(new URL(path, project), project)) {
+                copied.push({ path: file.target, state: 'outside' });
+                continue;
+            }
+            if (path) {
+                named.add(path);
+                folders.add(folderOf(path));
+            }
+            const text = path && (await readFile(new URL(path, project), 'utf8').catch(() => undefined));
+            if (!path || text === undefined)
+                continue;
+            const state = stateOf(text, await readFile(source, 'utf8'));
+            const to = installed.version;
+            copied.push(state === 'unknown' ? { path, state, to } : { path, state, from: marker.exec(text)[1], to, ...(!ejected.has(folderOf(path)) && { item: name }) });
+        }
+    }
+    // A marked file no item names any more: an item the package dropped, which the project deletes.
+    for (const folder of folders) {
+        const entries = await readdir(new URL(folder || './', project), { withFileTypes: true }).catch(() => []);
+        for (const entry of entries) {
+            const path = `${folder}${entry.name}`;
+            if (!entry.isFile() || named.has(path))
+                continue;
+            const from = marker.exec(await readFile(new URL(path, project), 'utf8'))?.[1];
+            if (from)
+                copied.push({ path, state: 'removed', from });
+        }
+    }
+    return copied;
+};
+const sentence = ({ path, state, from = '', to = 'unknown', item }) => ({
+    'up to date': `${path} is up to date.`,
+    'up to date, edited': `${path} is up to date, and edited since it was ejected.`,
+    differs: `${path} differs from the installed mithaq-admin's file (${to}), and is not edited since it was ejected from ${from.slice(0, 12)}. A hash shows a difference, not which side is newer: diff the two before replacing it, or ${item ? `delete it and run \`mithaq eject ${item}\` to take the package's` : 'delete it to draw the package\'s'}.`,
+    'differs, edited': `${path} differs from the installed mithaq-admin's file (${to}), and is edited since it was ejected from ${from.slice(0, 12)}: diff the two and merge by hand.`,
+    unknown: `${path} carries no mithaq-admin marker on its last line, so nothing says what it was ejected from.`,
+    outside: `${path} resolves outside this project or the package, so it was not read.`,
+    removed: `${path} was ejected from mithaq-admin ${from.slice(0, 12)}, and no item of the installed package names it any more: it was removed from the package, so delete it.`,
+})[state];
+const noComponents = 'No components.json here, so nothing says where mithaq-admin files go.';
+const noPackage = 'No mithaq-admin is installed here.';
+/** `mithaq upgrade --check`: one line per file the project holds, and 1 where any differs. It never writes. */
+export const run = async (project) => {
+    if (!existsSync(new URL('components.json', project))) {
+        console.log(noComponents);
+        return 0;
+    }
+    const copied = await upgradeCheck(project);
+    if (!copied) {
+        console.log(`${noPackage} Nothing to check the files against.`);
+        return 0;
+    }
+    if (!copied.length)
+        console.log('Nothing from mithaq-admin here.');
+    for (const one of copied)
+        console.log(sentence(one));
+    const differing = copied.filter((one) => one.state.startsWith('differs')).length;
+    if (differing) {
+        console.error(`${differing} ${differing === 1 ? 'file differs' : 'files differ'} from the installed mithaq-admin.`);
+        return 1;
+    }
+    return 0;
+};
+/**
+ * `mithaq eject <item>`: writes the item's own files where the project keeps them, each byte for byte with a marker,
+ * and never over a file already there. It copies no other item and installs nothing: the package serves every
+ * sibling, so it only names a primitive or an npm package the project lacks.
+ */
+export const eject = async (project, name) => {
+    if (!existsSync(new URL('components.json', project))) {
+        console.error(noComponents);
+        return 1;
+    }
+    const pathOf = await targetsOf(project);
+    const installed = await installedOf(project);
+    if (!installed) {
+        console.error(`${noPackage} Install it at the version of mithaq, then eject.`);
+        return 1;
+    }
+    const wanted = `mithaq-${name.replace(/\.tsx?$/, '').replace(/^mithaq-/, '')}`;
+    const item = installed.items.find((one) => one.name === wanted);
+    if (!item) {
+        console.error(`mithaq-admin has no item "${name}". Its items are: ${installed.items.map((one) => one.name).join(', ')}.`);
+        return 1;
+    }
+    const files = item.files.map((file) => ({ source: new URL(file.path, installed.root), path: pathOf(file.target), target: file.target }));
+    const refused = files.filter(({ source, path }) => !within(source, installed.root) || !path || !within(new URL(path, project), project));
+    if (refused.length) {
+        console.error(`${refused.map((one) => one.target).join(', ')} resolves outside this project or the package, so nothing was written.`);
+        return 1;
+    }
+    const ejected = ejectedFolders(installed.items, pathOf);
+    for (const { source, path } of files) {
+        const at = new URL(path, project);
+        const text = await readFile(source, 'utf8');
+        await mkdir(new URL('./', at), { recursive: true });
+        // `wx` fails on a file already there, so an eject never overwrites, whatever raced it.
+        const body = bodyOf(text);
+        const written = await writeFile(at, `${body}// mithaq-admin ${installed.version} ${sha(body)}\n`, { flag: 'wx' }).then(() => true, (error) => {
+            if (error.code === 'EEXIST')
+                return false;
+            throw error;
+        });
+        // A file the project always holds (the host, storage, a step) is never deleted: the app needs it.
+        const drawn = ejected.has(folderOf(path)) ? '; delete it to draw mithaq-admin\'s again' : '';
+        console.log(written ? `${path} is ejected. Edit it in place${drawn}.` : `${path} is already ejected, so it was left as it is.`);
+    }
+    for (const primitive of item.registryDependencies ?? []) {
+        const path = pathOf(`@ui/${primitive}.tsx`);
+        if (path && !existsSync(new URL(path, project)))
+            console.log(`${path} is missing: run shadcn add ${primitive}`);
+    }
+    const require = createRequire(new URL('package.json', project));
+    for (const dependency of item.dependencies ?? []) {
+        const npm = /^(@?[^@]+)/.exec(dependency)[1];
+        try {
+            require.resolve(npm);
+        }
+        catch (error) {
+            if (error.code === 'MODULE_NOT_FOUND')
+                console.log(`${npm} is not installed: install ${dependency}`);
+        }
+    }
+    return 0;
+};
+/**
+ * `mithaq eject --prune`: deletes every marked file in the folders pieces are ejected into whose text still hashes
+ * to its marker, so the package draws it again. Never an edited, unmarked or `~/` file.
+ */
+export const prune = async (project) => {
+    if (!existsSync(new URL('components.json', project))) {
+        console.error(noComponents);
+        return 1;
+    }
+    const pathOf = await targetsOf(project);
+    const installed = await installedOf(project);
+    if (!installed) {
+        console.error(noPackage);
+        return 1;
+    }
+    // The package's file at each path, whose leading comments a copy `shadcn add` made may hold and no more.
+    const sources = new Map(installed.items.flatMap((item) => item.files.flatMap((file) => {
+        const path = pathOf(file.target);
+        return path ? [[path, new URL(file.path, installed.root)]] : [];
+    })));
+    const leadOf = (text) => leading.exec(bodyOf(text))[0];
+    for (const folder of ejectedFolders(installed.items, pathOf)) {
+        if (!within(new URL(folder, project), project))
+            continue;
+        const entries = await readdir(new URL(folder, project), { withFileTypes: true }).catch(() => []);
+        for (const entry of entries) {
+            if (!entry.isFile())
+                continue;
+            const path = `${folder}${entry.name}`;
+            const text = await readFile(new URL(path, project), 'utf8');
+            const [, from, hash] = marker.exec(text) ?? [];
+            if (!hash || hash !== hashFrom(from)(text))
+                continue;
+            // A commit's hash leaves leading comments out, so a pragma written above one is an edit the hash cannot see.
+            const source = sources.get(path);
+            const lead = leadOf(text);
+            if (madeByShadcn(from) && lead && lead !== (source && within(source, installed.root) ? leadOf(await readFile(source, 'utf8').catch(() => '')) : ''))
+                continue;
+            await rm(new URL(path, project));
+            console.log(`${path} was not edited since it was ejected, so it is deleted and mithaq-admin draws its own.`);
+        }
+    }
+    return 0;
+};

package/dist/asas/http/fetch.d.ts

@@ -0,0 +1,41 @@
+import type { HttpPlug, OperationTable } from '../build.ts';
+import type { StandardSchemaV1 } from '../../mithaq/standard-schema.ts';
+/** The Zod input decides which JSON strings represent dates on either HTTP plug. */
+export declare const decodeJson: (value: unknown, schema: StandardSchemaV1) => unknown;
+export declare const draftOptions: (request: Request) => {
+    draft?: boolean | undefined;
+    autosave?: boolean | undefined;
+    tenant?: string | undefined;
+};
+/**
+ * The largest request body a plug reads, which a project names as `maxBodyBytes`: room for a
+ * json field's `defaultJsonMaxBytes` written in any script. A file never comes this way.
+ */
+export declare const defaultMaxBodyBytes: number;
+/**
+ * The body, or the answer that refuses it: 413 once it passes `limit` bytes, and 499 to a client
+ * that went away mid-body, which is no fault of the server's. Counted as it arrives, since a
+ * `content-length` may be absent or wrong, and the rest is never read.
+ */
+export declare const boundedBody: (request: Request, limit: number) => Promise<Blob | Response>;
+/** Refused by name, since core holds no limit of its own. */
+export declare const assertMaxBodyBytes: (owner: string, value: unknown) => void;
+/** Refused by name, as `auth.onError` and `storage.onError` are: core reports no fault of its own. */
+export declare const assertOnError: (owner: string, value: unknown) => void;
+export declare const tooLarge: (limit: number) => Response;
+export type FetchHttpOptions = {
+    /** The largest body a call takes, answered 413 past it: `defaultMaxBodyBytes` or the project's own. Required. */
+    maxBodyBytes: number;
+    /**
+     * Builds the context every step of a served call reads, from the request and the actor.
+     * The plug reads no header or body key into it; a throw is answered 500.
+     */
+    context?: (request: Request, actor: unknown) => Promise<Record<string, unknown>> | Record<string, unknown>;
+    /** Handed every error that is not an `AsasError`, before the 500 goes out with its message replaced. Required. */
+    onError: (error: unknown) => void;
+};
+/**
+ * The default HTTP plug: `POST /api/<kayan>/<operation>` with a JSON body, over
+ * `Request` and `Response` alone. The runner parses each operation's input.
+ */
+export declare const fetchHttp: (options: FetchHttpOptions) => <View>(operations: OperationTable<View>) => HttpPlug;