@funpixel/tools 0.0.0-stage → 0.1.0

package/dist/trailer/mix.js

@@ -0,0 +1,109 @@
+import { spawnSync } from 'node:child_process';
+export const MIX = {
+    musicDb: -4,
+    sfxDb: -3,
+    duckDb: 5,
+    fadeOut: 2,
+    fadeIn: 0.2,
+    lufs: -16,
+    truePeak: -1.5,
+    lra: 11,
+    rate: 48000,
+};
+export const HEADROOM_DB = 12;
+export const DUCK_DRY = Math.pow(10, -MIX.duckDb / 20);
+const db = (d) => Math.pow(10, d / 20);
+const f = (n, d = 4) => n.toFixed(d);
+export function mixArgs(input, out) {
+    if (!input.music && !input.cues.length)
+        return null;
+    const T = input.total;
+    const args = ['-hide_banner', '-loglevel', 'error', '-y'];
+    let n = 0;
+    const graph = [];
+    const fmt = `aformat=sample_fmts=fltp:sample_rates=${MIX.rate}:channel_layouts=stereo`;
+    let music = -1;
+    if (input.music) {
+        args.push('-stream_loop', '-1', '-ss', f(input.music.offset, 3), '-i', input.music.file);
+        music = n++;
+    }
+    const files = [...new Set(input.cues.map((c) => c.file))];
+    const inputOf = new Map();
+    for (const file of files) {
+        args.push('-i', file);
+        inputOf.set(file, n++);
+    }
+    const uses = new Map();
+    input.cues.forEach((c, i) => { const l = uses.get(c.file) ?? []; l.push(`u${i}`); uses.set(c.file, l); });
+    for (const file of files) {
+        const labels = uses.get(file);
+        graph.push(`[${inputOf.get(file)}:a]${fmt}${labels.length > 1 ? `,asplit=${labels.length}${labels.map((l) => `[${l}]`).join('')}` : `[${labels[0]}]`}`);
+    }
+    input.cues.forEach((c, i) => {
+        const len = Math.max(0.03, c.length);
+        const fade = Math.min(0.06, len / 3);
+        const ms = Math.max(0, Math.round(c.at * 1000));
+        const rate = c.rate > 0 && Math.abs(c.rate - 1) > 0.005 ? `,asetrate=${Math.round(MIX.rate * c.rate)},aresample=${MIX.rate}` : '';
+        graph.push(`[u${i}]atrim=start=${f(c.offset, 3)},asetpts=PTS-STARTPTS${rate},atrim=duration=${f(len, 3)},`
+            + `afade=t=out:st=${f(len - fade, 3)}:d=${f(fade, 3)},volume=${f(Math.max(0, c.gain) * db(MIX.sfxDb))},adelay=${ms}|${ms}[c${i}]`);
+    });
+    const pad = `apad=whole_dur=${f(T, 3)},atrim=duration=${f(T, 3)}`;
+    if (input.cues.length) {
+        graph.push(input.cues.length > 1
+            ? `${input.cues.map((_, i) => `[c${i}]`).join('')}amix=inputs=${input.cues.length}:normalize=0:duration=longest,${pad}[sfx]`
+            : `[c0]${pad}[sfx]`);
+    }
+    if (music >= 0) {
+        graph.push(`[${music}:a]${fmt},atrim=duration=${f(T, 3)},asetpts=PTS-STARTPTS,volume=${f(db(MIX.musicDb))},`
+            + `afade=t=in:d=${MIX.fadeIn},afade=t=out:st=${f(Math.max(0, T - MIX.fadeOut), 3)}:d=${f(Math.min(MIX.fadeOut, T), 3)},${pad}[bed]`);
+    }
+    if (music >= 0 && input.cues.length) {
+        graph.push('[sfx]asplit=2[sfxo][sc]', '[bed]asplit=2[bd][bc]', '[bc][sc]sidechaincompress=threshold=0.003:ratio=20:attack=5:release=250:makeup=1[bw]', `[bd]volume=${f(DUCK_DRY)}[bdd]`, `[bw]volume=${f(1 - DUCK_DRY)}[bww]`, '[bdd][bww]amix=inputs=2:normalize=0[ducked]', `[ducked][sfxo]amix=inputs=2:normalize=0:duration=first,${pad},volume=${f(db(-HEADROOM_DB))}[mix]`);
+    }
+    else {
+        graph.push(`[${music >= 0 ? 'bed' : 'sfx'}]volume=${f(db(-HEADROOM_DB))}[mix]`);
+    }
+    args.push('-filter_complex', graph.join(';'), '-map', '[mix]', '-c:a', 'pcm_f32le', '-ar', String(MIX.rate), out);
+    return args;
+}
+const target = `I=${MIX.lufs}:TP=${MIX.truePeak}:LRA=${MIX.lra}`;
+export function parseLoudnorm(stderr) {
+    const at = stderr.lastIndexOf('{');
+    if (at < 0)
+        return null;
+    try {
+        const j = JSON.parse(stderr.slice(at, stderr.indexOf('}', at) + 1));
+        return [j.input_i, j.input_tp, j.input_lra, j.input_thresh, j.target_offset].every((v) => v !== undefined && Number.isFinite(Number(v))) ? j : null;
+    }
+    catch {
+        return null;
+    }
+}
+export const measureArgs = (file) => ['-hide_banner', '-nostats', '-i', file, '-af', `loudnorm=${target}:print_format=json`, '-f', 'null', '-'];
+export const normalizeArgs = (file, m, out) => [
+    '-hide_banner', '-loglevel', 'error', '-y', '-i', file, '-af',
+    `loudnorm=${target}:measured_I=${m.input_i}:measured_TP=${m.input_tp}:measured_LRA=${m.input_lra}`
+        + `:measured_thresh=${m.input_thresh}:offset=${m.target_offset}:linear=true,aresample=${MIX.rate}`,
+    '-c:a', 'pcm_s16le', '-ar', String(MIX.rate), '-ac', '2', out,
+];
+export function mixdown(bin, input, pre, out) {
+    const args = mixArgs(input, pre);
+    if (!args)
+        return { ok: false, error: 'nothing to mix' };
+    const tail = (s, fallback) => (s || fallback).trim().split('\n').slice(-3).join(' ');
+    const a = spawnSync(bin, args, { encoding: 'utf8', maxBuffer: 16 * 1024 * 1024 });
+    if (a.status !== 0)
+        return { ok: false, error: tail(a.stderr, `mix exited ${a.status}`) };
+    const m = spawnSync(bin, measureArgs(pre), { encoding: 'utf8', maxBuffer: 16 * 1024 * 1024 });
+    if (/"input_i"\s*:\s*"-inf"/.test(m.stderr ?? ''))
+        return { ok: false, error: 'the mix is silent' };
+    const measured = parseLoudnorm(m.stderr ?? '');
+    if (!measured)
+        return { ok: false, error: tail(m.stderr, 'loudnorm measured nothing') };
+    if (!Number.isFinite(Number(measured.input_i)) || Number(measured.input_i) < -70)
+        return { ok: false, error: 'the mix is silent' };
+    const b = spawnSync(bin, normalizeArgs(pre, measured, out), { encoding: 'utf8', maxBuffer: 16 * 1024 * 1024 });
+    if (b.status !== 0)
+        return { ok: false, error: tail(b.stderr, `loudnorm exited ${b.status}`) };
+    return { ok: true };
+}

package/dist/trailer/placement.js

@@ -0,0 +1,30 @@
+export const SAFE = {
+    '9x16': { top: 0.13, right: 0.15, bottom: 0.22, left: 0.06 },
+    '4x5': { top: 0.06, right: 0.06, bottom: 0.1, left: 0.06 },
+    '1x1': { top: 0.06, right: 0.06, bottom: 0.1, left: 0.06 },
+    '16x9': { top: 0.07, right: 0.05, bottom: 0.12, left: 0.05 },
+};
+export const DESTINATIONS = {
+    tiktok: '9x16', reels: '9x16', shorts: '9x16', stories: '9x16',
+    feed: '4x5', square: '1x1', youtube: '16x9', store: '16x9', site: '16x9',
+};
+export function formatsFor(places) {
+    const out = [];
+    for (const p of places) {
+        const f = DESTINATIONS[p.toLowerCase()];
+        if (!f)
+            return `--for ${p}: one of ${Object.keys(DESTINATIONS).join(', ')}`;
+        if (!out.includes(f))
+            out.push(f);
+    }
+    return out;
+}
+export function safeRect(name, width, height) {
+    const s = SAFE[name];
+    const x = Math.round(width * s.left), y = Math.round(height * s.top);
+    return { x, y, w: Math.round(width * (1 - s.left - s.right)), h: Math.round(height * (1 - s.top - s.bottom)) };
+}
+export function insideSafe(name, width, height, box) {
+    const r = safeRect(name, width, height);
+    return box.x >= r.x && box.y >= r.y && box.x + box.w <= r.x + r.w && box.y + box.h <= r.y + r.h;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/ui.js

@@ -0,0 +1,79 @@
+const SGR = { green: [32, 39], red: [31, 39], cyan: [36, 39], yellow: [33, 39], dim: [2, 22], bold: [1, 22] };
+export const MARKS = {
+    pass: { word: 'pass', unicode: '✓', ascii: '+', color: 'green' },
+    fail: { word: 'FAIL', unicode: '✗', ascii: 'x', color: 'red' },
+    not_observed: { word: 'not observed', unicode: '○', ascii: 'o', color: 'cyan' },
+    warn: { word: 'warn', unicode: '!', ascii: '!', color: 'yellow' },
+    skip: { word: 'skip', unicode: '–', ascii: '-', color: 'dim' },
+    note: { word: 'note', unicode: '·', ascii: '.', color: 'dim' },
+    todo: { word: 'to do', unicode: '□', ascii: '_', color: 'yellow' },
+};
+const WORD_WIDTH = Math.max(...Object.values(MARKS).map((m) => m.word.length));
+export function detect(env = process.env, stream = process.stdout, platform = process.platform) {
+    const tty = stream.isTTY === true && env.TERM !== 'dumb';
+    const forced = env.FORCE_COLOR;
+    const color = forced !== undefined ? !['0', 'false'].includes(forced) : env.NO_COLOR ? false : tty;
+    const legacyConsole = platform === 'win32' && !env.WT_SESSION && !env.TERM_PROGRAM;
+    const unicode = env.FUNTOOLS_ASCII !== '1' && env.TERM !== 'dumb' && !legacyConsole;
+    return { color, unicode, tty };
+}
+export const PLAIN = { color: false, unicode: true, tty: false };
+export function ui(io, command, caps) {
+    const real = io === console && !caps;
+    caps ??= real ? detect() : PLAIN;
+    const errColor = real ? detect(process.env, process.stderr).color : caps.color;
+    const sgr = (on, color, text) => (on ? `\x1b[${SGR[color][0]}m${text}\x1b[${SGR[color][1]}m` : text);
+    const paint = (color, text) => sgr(caps.color, color, text);
+    const mark = (s) => {
+        const m = MARKS[s];
+        return paint(m.color, `${caps.unicode ? m.unicode : m.ascii} ${m.word.padEnd(WORD_WIDTH)}`);
+    };
+    const pad = (depth) => '  '.repeat(depth);
+    const u = {
+        caps,
+        paint,
+        mark,
+        heading: (text) => io.log(paint('bold', text)),
+        item: (s, text, detail) => io.log(`${pad(1)}${mark(s)}  ${text}${detail ? ` — ${detail}` : ''}`),
+        line: (text, depth = 1) => io.log(`${pad(depth)}${text}`),
+        summary: (s, text) => {
+            const m = MARKS[s];
+            io.log(paint(m.color, `${caps.unicode ? m.unicode : m.ascii} ${command}: `) + text);
+        },
+        error: (what, next) => io.error(`${sgr(errColor, 'red', `funtools ${command}:`)} ${what}${next ? ` — ${next}` : ''}`),
+        progress() {
+            let last = '';
+            const live = caps.tty && io === console;
+            return {
+                update(text) {
+                    if (text === last)
+                        return;
+                    last = text;
+                    if (live)
+                        process.stdout.write(`\r\x1b[2K${pad(1)}${paint('dim', caps.unicode ? '…' : '...')} ${text}`);
+                    else
+                        io.log(`${pad(1)}${mark('note')}  ${text}`);
+                },
+                done(s, text) {
+                    if (live)
+                        process.stdout.write('\r\x1b[2K');
+                    u.item(s, text);
+                },
+            };
+        },
+    };
+    return u;
+}
+export async function askYes(io, u, question) {
+    if (io !== console || !process.stdin.isTTY || !process.stdout.isTTY)
+        return false;
+    const { createInterface } = await import('node:readline/promises');
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        return /^y(es)?$/i.test((await rl.question(`  ${u.mark('warn')}  ${question} [y/N] `)).trim());
+    }
+    finally {
+        rl.close();
+    }
+}
+export const verdictWord = (s) => s.replace('_', ' ').toUpperCase();

package/dist/unity/bridge.js

@@ -0,0 +1,251 @@
+import { createHash } from 'node:crypto';
+import { readFile, rm, writeFile, mkdir, rename } from 'node:fs/promises';
+import { connect } from 'node:net';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { projectKey, projectNames } from "./queue.js";
+export const BRIDGE_VERSION = '10.3.0';
+export const BRIDGE_PACKAGE = 'com.coplaydev.unity-mcp';
+export const BRIDGE_URL = `https://github.com/CoplayDev/unity-mcp.git?path=/MCPForUnity#v${BRIDGE_VERSION}`;
+export const BRIDGE_SERVER = ['uvx', '--from', `mcpforunityserver==${BRIDGE_VERSION}`, 'mcp-for-unity', '--transport', 'stdio'];
+export const STDIO_BOOT = 'MCPForUnity.Editor.McpCiBoot.StartStdioForCi';
+export const BRIDGE_TOOLS = [
+    'apply_text_edits', 'batch_execute', 'blender_bridge', 'create_script', 'debug_request_context',
+    'delete_script', 'execute_code', 'execute_custom_tool', 'execute_menu_item', 'find_gameobjects',
+    'find_in_file', 'generate_audio', 'generate_image', 'generate_model', 'get_sha', 'get_test_job',
+    'import_model', 'import_model_file', 'manage_animation', 'manage_asset', 'manage_build',
+    'manage_camera', 'manage_components', 'manage_editor', 'manage_gameobject', 'manage_graphics',
+    'manage_material', 'manage_packages', 'manage_physics', 'manage_prefabs', 'manage_probuilder',
+    'manage_profiler', 'manage_scene', 'manage_script', 'manage_script_capabilities',
+    'manage_scriptable_object', 'manage_shader', 'manage_texture', 'manage_tools', 'manage_ui',
+    'manage_vfx', 'read_console', 'refresh_unity', 'run_tests', 'script_apply_edits',
+    'set_active_instance', 'unity_docs', 'unity_reflect', 'validate_script',
+];
+export const RESOURCE_EDITOR_STATE = 'mcpforunity://editor/state';
+export const RESOURCE_PROJECT_INFO = 'mcpforunity://project/info';
+export const manifestPath = (project) => join(project, 'Packages', 'manifest.json');
+export function entryOf(value) {
+    const tag = /#v?(\d+\.\d+\.\d+[\w.-]*)$/.exec(value)?.[1];
+    const version = tag ?? (/^\d+\.\d+\.\d+/.test(value) ? value : value.startsWith('file:') ? 'local' : null);
+    return { value, version, pinned: value === BRIDGE_URL };
+}
+export function manifestEntry(text) {
+    const m = JSON.parse(text);
+    const v = m.dependencies?.[BRIDGE_PACKAGE];
+    return typeof v === 'string' ? entryOf(v) : null;
+}
+const depsOf = (text) => JSON.parse(text).dependencies ?? {};
+function onlyBridgeChanged(before, after, want) {
+    let a, b;
+    try {
+        a = depsOf(before);
+        b = depsOf(after);
+    }
+    catch {
+        return false;
+    }
+    const rest = (o) => JSON.stringify(Object.entries(o).filter(([k]) => k !== BRIDGE_PACKAGE));
+    let whole;
+    try {
+        const strip = (t) => { const o = JSON.parse(t); delete o.dependencies; return JSON.stringify(o); };
+        whole = strip(before) === strip(after);
+    }
+    catch {
+        return false;
+    }
+    return whole && rest(a) === rest(b) && b[BRIDGE_PACKAGE] === want;
+}
+export function addToManifest(text) {
+    let deps;
+    try {
+        deps = depsOf(text);
+    }
+    catch (e) {
+        return { error: `Packages/manifest.json is not JSON (${e.message})` };
+    }
+    if (BRIDGE_PACKAGE in deps)
+        return { error: `${BRIDGE_PACKAGE} is already in Packages/manifest.json` };
+    const open = /"dependencies"\s*:\s*\{/.exec(text);
+    if (!open)
+        return { error: 'Packages/manifest.json has no "dependencies" object' };
+    const at = open.index + open[0].length;
+    const after = text.slice(at);
+    const nl = text.includes('\r\n') ? '\r\n' : '\n';
+    const key = `"${BRIDGE_PACKAGE}": "${BRIDGE_URL}"`;
+    let out;
+    let line;
+    if (/^\s*\}/.test(after)) {
+        const indent = (/^[ \t]*/.exec(text.slice(text.lastIndexOf('\n', open.index) + 1))?.[0] ?? '');
+        line = `${indent}  ${key}`;
+        out = `${text.slice(0, at)}${nl}${line}${nl}${indent}${after.replace(/^\s*/, '')}`;
+    }
+    else {
+        const first = /^([ \t]*\r?\n)?([ \t]*)/.exec(after);
+        const indent = first[2] || '    ';
+        line = `${indent}${key},`;
+        out = first[1] !== undefined
+            ? `${text.slice(0, at)}${first[1]}${line}${nl}${after.slice(first[1].length)}`
+            : `${text.slice(0, at)} ${key},${after}`;
+    }
+    if (!onlyBridgeChanged(text, out, BRIDGE_URL))
+        return { error: 'could not add one line to Packages/manifest.json without touching anything else; add it by hand' };
+    return { text: out, line: line.trim() };
+}
+export function removeFromManifest(text) {
+    let deps;
+    try {
+        deps = depsOf(text);
+    }
+    catch (e) {
+        return { error: `Packages/manifest.json is not JSON (${e.message})` };
+    }
+    if (!(BRIDGE_PACKAGE in deps))
+        return { error: `${BRIDGE_PACKAGE} is not in Packages/manifest.json` };
+    const esc = BRIDGE_PACKAGE.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const lineRe = new RegExp(`(\\r?\\n)?([ \\t]*)"${esc}"\\s*:\\s*"(?:[^"\\\\]|\\\\.)*"[ \\t]*(,?)`);
+    const m = lineRe.exec(text);
+    if (!m)
+        return { error: `could not find ${BRIDGE_PACKAGE}'s line in Packages/manifest.json; remove it by hand` };
+    const removed = m[0].replace(/^\r?\n/, '').trim();
+    let out;
+    if (m[3] === ',')
+        out = text.slice(0, m.index) + text.slice(m.index + m[0].length);
+    else {
+        const before = text.slice(0, m.index).replace(/,(\s*)$/, '$1');
+        out = before + text.slice(m.index + m[0].length);
+    }
+    if (!onlyBridgeChanged(text, out, undefined))
+        return { error: 'could not take one line out of Packages/manifest.json without touching anything else; remove it by hand' };
+    return { text: out, line: removed };
+}
+export async function readManifest(project) {
+    let text;
+    try {
+        text = await readFile(manifestPath(project), 'utf8');
+    }
+    catch {
+        return { error: `${manifestPath(project)} is missing (not a Unity project, or never opened)` };
+    }
+    try {
+        return { text, entry: manifestEntry(text) };
+    }
+    catch (e) {
+        return { error: `Packages/manifest.json is not JSON (${e.message})` };
+    }
+}
+export async function writeManifest(project, text) {
+    const file = manifestPath(project);
+    const tmp = `${file}.funtools-${process.pid}.tmp`;
+    await writeFile(tmp, text);
+    await rename(tmp, file);
+}
+export const statusDir = (env = process.env) => env.UNITY_MCP_STATUS_DIR || join(homedir(), '.unity-mcp');
+export const assetsPaths = (project) => projectNames(project).map((p) => `${p}/Assets`);
+export const instanceHash = (assets, len = 8) => createHash('sha1').update(assets, 'utf8').digest('hex').slice(0, len);
+const same = (a, b) => a.replace(/\/+$/, '').toLowerCase() === b.replace(/\/+$/, '').toLowerCase();
+export async function findStatus(project, env = process.env) {
+    const spellings = assetsPaths(project);
+    for (const assets of spellings) {
+        const hash = instanceHash(assets);
+        const file = join(statusDir(env), `unity-mcp-status-${hash}.json`);
+        let data;
+        try {
+            data = JSON.parse(await readFile(file, 'utf8'));
+        }
+        catch {
+            continue;
+        }
+        const named = typeof data.project_path === 'string' ? data.project_path : '';
+        if (!spellings.some((s) => same(s, named)))
+            continue;
+        const name = typeof data.project_name === 'string' && data.project_name ? data.project_name : 'Unknown';
+        return {
+            file, id: `${name}@${hash}`, hash, projectPath: named,
+            port: typeof data.unity_port === 'number' ? data.unity_port : null,
+            reloading: data.reloading === true,
+            heartbeat: typeof data.last_heartbeat === 'string' ? data.last_heartbeat : null,
+            unityVersion: typeof data.unity_version === 'string' ? data.unity_version : null,
+        };
+    }
+    return null;
+}
+export function probe(port, timeoutMs = 1500, host = '127.0.0.1') {
+    return new Promise((ok) => {
+        let done = false;
+        let buf = Buffer.alloc(0);
+        let pinged = false;
+        const s = connect({ host, port });
+        const end = (v) => { if (done)
+            return; done = true; s.destroy(); ok(v); };
+        s.setTimeout(timeoutMs, () => end(false));
+        s.on('error', () => end(false));
+        s.on('data', (chunk) => {
+            buf = Buffer.concat([buf, chunk]);
+            if (!pinged) {
+                if (!buf.includes('FRAMING=1')) {
+                    end(false);
+                    return;
+                }
+                pinged = true;
+                buf = Buffer.alloc(0);
+                const head = Buffer.alloc(8);
+                head.writeBigUInt64BE(4n);
+                s.write(Buffer.concat([head, Buffer.from('ping')]));
+                return;
+            }
+            if (buf.length >= 8) {
+                const n = Number(buf.readBigUInt64BE(0));
+                if (buf.length >= 8 + n)
+                    end(/pong/i.test(buf.subarray(8, 8 + n).toString('utf8')));
+            }
+        });
+        s.on('close', () => end(false));
+    });
+}
+export async function reach(project, env = process.env, now = Date.now(), ping = probe) {
+    const status = await findStatus(project, env);
+    if (!status)
+        return { status, reachable: false, why: `no MCP for Unity status file for this project in ${statusDir(env)} (no Editor has started the stdio bridge on it)` };
+    if (status.port === null)
+        return { status, reachable: false, why: `${status.file} names no port` };
+    if (await ping(status.port))
+        return { status, reachable: true, why: `answers on port ${status.port}` };
+    const age = status.heartbeat ? now - Date.parse(status.heartbeat) : Infinity;
+    if (status.reloading && age < 60_000)
+        return { status, reachable: true, why: `reloading scripts (heartbeat ${Math.round(age / 1000)} s ago); calls wait for it` };
+    return { status, reachable: false, why: `nothing answers on port ${status.port} (last heartbeat ${status.heartbeat ?? 'never'})` };
+}
+export const editorsDir = (machine) => join(machine, 'unity-editors');
+const openedFile = (root, project) => join(root, `${projectKey(project)}.json`);
+export async function readOpened(root, project) {
+    try {
+        return JSON.parse(await readFile(openedFile(root, project), 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeOpened(root, rec) {
+    await mkdir(root, { recursive: true });
+    const file = openedFile(root, rec.project);
+    const tmp = `${file}.${process.pid}.tmp`;
+    await writeFile(tmp, JSON.stringify(rec, null, 2) + '\n');
+    await rename(tmp, file);
+}
+export async function dropOpened(root, project) {
+    await rm(openedFile(root, project), { force: true });
+}
+const markFile = (root, project) => join(root, `${projectKey(project)}.console`);
+export async function readMark(root, project) {
+    try {
+        const n = Number((await readFile(markFile(root, project), 'utf8')).trim());
+        return Number.isInteger(n) && n >= 0 ? n : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeMark(root, project, n) {
+    await mkdir(root, { recursive: true });
+    await writeFile(markFile(root, project), `${n}\n`);
+}