@funpixel/tools 0.0.0-stage → 0.1.1

package/dist/judge/structure.js

@@ -0,0 +1,59 @@
+import { readFileSync } from 'node:fs';
+import { filing, hasEvidence, PANEL } from "./common.js";
+export const STRUCTURE_RUBRIC = 1;
+export const QUESTIONS = [
+    { id: 'pairs', na: true, ask: 'Parts that come in sets (wheels, eyes, ears, arms, legs, wings, lights, handles) match one another in shape, size and detail, allowing for perspective and pose.' },
+    { id: 'count', na: false, ask: 'Every part the description names or the subject implies is there the right number of times: one head, two eyes on a face, four legs on a dog, four wheels on a car (two in a side view), five fingers on a drawn hand — no extra, none missing.' },
+    { id: 'attached', na: true, ask: 'Every limb, wheel, handle, tail and accessory joins the body where it belongs; nothing floats free, melts into a neighbouring part, or grows from the wrong place.' },
+    { id: 'text', na: true, ask: 'Any lettering, numbers or symbols are legible and spelled as meant, with no near-letters or invented glyphs.' },
+    { id: 'whole', na: true, ask: 'The whole subject is inside the frame: nothing the description names is cut off by an edge (n/a for a tile or texture meant to run off the edge).' },
+];
+export function structurePrompt(pics, subject, answer) {
+    const keys = QUESTIONS.map((q, i) => `        "${q.id}": { "answer": "yes|no${q.na ? '|n/a' : ''}", "evidence": "…" }${i < QUESTIONS.length - 1 ? ',' : ''}`).join('\n');
+    return readFileSync(new URL('asset-structure.md', PANEL), 'utf8')
+        .replaceAll('{{SUBJECT}}', subject?.trim() || 'No description was given: judge each part against what the subject plainly is (a car has four wheels, a face two eyes).')
+        .replaceAll('{{IMAGES}}', pics.map((p) => `- ${p.label}: ${p.file}`).join('\n'))
+        .replaceAll('{{QUESTIONS}}', QUESTIONS.map((q) => `- **${q.id}**: ${q.ask}${q.na ? '' : ' (never n/a)'}`).join('\n'))
+        .replaceAll('{{ANSWER_KEYS}}', keys) + filing(answer);
+}
+function normalise(a) {
+    const s = String(a ?? '').trim().toLowerCase();
+    if (s === 'yes' || s === 'no')
+        return s;
+    if (/^(n\/?a|not applicable|none)$/.test(s))
+        return 'n/a';
+    return 'unseen';
+}
+export function judgePic(p, entry) {
+    if (!entry || typeof entry !== 'object')
+        return { image: p.label, file: p.file, state: 'not_observed', findings: QUESTIONS.map((q) => ({ question: q.id, answer: 'unseen', evidence: '', why: 'no answer for this picture' })) };
+    const findings = QUESTIONS.map((q) => {
+        const raw = entry.answers?.[q.id];
+        const evidence = typeof raw?.evidence === 'string' ? raw.evidence.trim() : '';
+        let answer = normalise(raw?.answer ?? raw);
+        let why;
+        if (answer === 'n/a' && !q.na) {
+            answer = 'unseen';
+            why = `${q.id} is never n/a`;
+        }
+        else if (answer === 'unseen')
+            why = raw === undefined ? 'not answered' : `answered "${String(raw?.answer ?? raw).slice(0, 40)}"`;
+        else if (answer !== 'n/a' && !hasEvidence(evidence)) {
+            answer = 'unseen';
+            why = 'no evidence given';
+        }
+        return { question: q.id, answer, evidence, ...(why ? { why } : {}) };
+    });
+    const state = findings.some((f) => f.answer === 'no') ? 'fail' : findings.some((f) => f.answer === 'unseen') ? 'not_observed' : 'pass';
+    return { image: p.label, file: p.file, state, ...(typeof entry.seen === 'string' ? { seen: entry.seen } : {}), findings };
+}
+export function judgeStructure(pics, answer) {
+    const list = Array.isArray(answer?.images) ? answer.images : [];
+    const pictures = pics.map((p, i) => judgePic(p, list.find((e) => String(e?.image ?? '').trim() === p.label) ?? (list.every((e) => !e?.image) ? list[i] : undefined)));
+    return { state: overall(pictures.map((v) => v.state)), pictures };
+}
+export function overall(states) {
+    if (!states.length)
+        return 'not_observed';
+    return states.includes('fail') ? 'fail' : states.includes('not_observed') ? 'not_observed' : 'pass';
+}

package/dist/keys/device.js

@@ -0,0 +1,145 @@
+import { apiBase } from "../api/http.js";
+import { openTarget } from "../dev/open.js";
+const CLIENT_ID = 'cjeKWp8QiPUJTFnA';
+const ISSUER = 'https://clerk.funpixel.ai';
+const DEVICE_GRANT = 'urn:ietf:params:oauth:grant-type:device_code';
+export function authorizePage(env = process.env, api = apiBase()) {
+    const set = env.FUNPIXEL_AUTHORIZE_URL?.trim();
+    if (set) {
+        if (/^(off|none|0|false)$/i.test(set))
+            return null;
+        return /^https?:\/\/\S+$/.test(set) ? set : null;
+    }
+    let u;
+    try {
+        u = new URL(api);
+    }
+    catch {
+        return null;
+    }
+    if (u.hostname.startsWith('api.'))
+        return `${u.protocol}//app.${u.hostname.slice(4)}${u.port ? `:${u.port}` : ''}/device`;
+    if ((u.hostname === 'localhost' || u.hostname === '127.0.0.1') && u.port === '7360')
+        return `${u.protocol}//${u.hostname}:5173/device`;
+    return null;
+}
+export function authorizeLink(page, userCode, host) {
+    const u = new URL(page);
+    u.searchParams.set('code', userCode);
+    if (host)
+        u.searchParams.set('host', host);
+    return u.toString();
+}
+export function oauthConfig(env = process.env) {
+    const get = (k) => env[k]?.trim() || undefined;
+    const clientId = get('FUNPIXEL_OAUTH_CLIENT_ID') ?? CLIENT_ID;
+    if (!clientId || /^(off|none|0|false)$/i.test(clientId))
+        return null;
+    return {
+        issuer: (get('FUNPIXEL_OAUTH_ISSUER') ?? ISSUER).replace(/\/$/, ''),
+        clientId,
+        scope: get('FUNPIXEL_OAUTH_SCOPE') ?? 'profile email',
+        resource: get('FUNPIXEL_OAUTH_RESOURCE') ?? `${apiBase()}/v1/cli/keys`,
+        authorizePage: authorizePage(env),
+    };
+}
+export const realDeps = {
+    fetch: (...a) => fetch(...a),
+    sleep: (ms) => new Promise((r) => setTimeout(r, ms)),
+    now: () => Date.now(),
+    open: (url) => openTarget(url),
+};
+export class SignInError extends Error {
+    declined;
+    constructor(message, declined = false) {
+        super(message);
+        this.declined = declined;
+    }
+}
+async function readJson(res) {
+    const text = await res.text().catch(() => '');
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return {};
+    }
+}
+async function post(deps, url, form) {
+    let res;
+    try {
+        res = await deps.fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded', Accept: 'application/json' },
+            body: new URLSearchParams(form).toString(),
+        });
+    }
+    catch (e) {
+        throw new SignInError(`could not reach ${new URL(url).host}: ${e instanceof Error ? e.message : String(e)} — check the connection and try again`);
+    }
+    return { status: res.status, body: await readJson(res) };
+}
+async function endpoints(cfg, deps) {
+    const url = `${cfg.issuer}/.well-known/openid-configuration`;
+    let doc = {};
+    try {
+        const res = await deps.fetch(url, { headers: { Accept: 'application/json' } });
+        if (res.ok)
+            doc = await readJson(res);
+    }
+    catch { }
+    const device = doc.device_authorization_endpoint, token = doc.token_endpoint;
+    if (typeof device !== 'string' || typeof token !== 'string') {
+        throw new SignInError(`${cfg.issuer} offers no device sign-in — use \`funtools login --key -\` with a key from Settings › Developers`);
+    }
+    return { device, token };
+}
+export async function deviceSignIn(cfg, show, deps = realDeps) {
+    const ep = await endpoints(cfg, deps);
+    const start = await post(deps, ep.device, { client_id: cfg.clientId, scope: cfg.scope, resource: cfg.resource });
+    const b = start.body;
+    if (start.status !== 200 || typeof b.device_code !== 'string' || typeof b.user_code !== 'string') {
+        const why = typeof b.error_description === 'string' ? b.error_description : b.error ?? `HTTP ${start.status}`;
+        throw new SignInError(`the sign-in server refused to start (${why}) — use \`funtools login --key -\` meanwhile`, true);
+    }
+    show({ userCode: b.user_code, uri: b.verification_uri ?? b.verification_url ?? cfg.issuer, complete: b.verification_uri_complete });
+    let interval = Math.max(1, Number(b.interval) || 5) * 1000;
+    const deadline = deps.now() + Math.max(30, Number(b.expires_in) || 600) * 1000;
+    while (deps.now() < deadline) {
+        await deps.sleep(interval);
+        const r = await post(deps, ep.token, { grant_type: DEVICE_GRANT, device_code: b.device_code, client_id: cfg.clientId, resource: cfg.resource });
+        if (r.status === 200 && typeof r.body.access_token === 'string')
+            return r.body.access_token;
+        switch (r.body.error) {
+            case 'authorization_pending': continue;
+            case 'slow_down':
+                interval += 5000;
+                continue;
+            case 'access_denied': throw new SignInError('the sign-in was declined in the browser — run `funtools login` again to retry', true);
+            case 'expired_token': throw new SignInError('the code expired before it was approved — run `funtools login` again', true);
+            default: throw new SignInError(`the sign-in server said ${r.body.error ?? `HTTP ${r.status}`} — run \`funtools login\` again, or use \`--key -\``, true);
+        }
+    }
+    throw new SignInError('the code expired before it was approved — run `funtools login` again', true);
+}
+export async function mintKey(token, hostname, deps = realDeps, base = apiBase(), scopes) {
+    let res;
+    try {
+        res = await deps.fetch(`${base}/v1/cli/keys`, {
+            method: 'POST',
+            headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
+            body: JSON.stringify(scopes ? { hostname, scopes } : { hostname }),
+        });
+    }
+    catch (e) {
+        throw new SignInError(`could not reach ${base}: ${e instanceof Error ? e.message : String(e)} — check FUNPIXEL_API_URL and the connection`);
+    }
+    const body = await readJson(res);
+    if (res.status !== 201 || typeof body.secret !== 'string') {
+        const code = typeof body.code === 'string' ? ` ${body.code}` : '';
+        const next = body.code === 'paid_plan_required' ? 'API and CLI access needs a paid plan' : 'or make a key in Settings › Developers and use `funtools login --key -`';
+        throw new SignInError(`the server would not issue a key (${res.status}${code}): ${body.error ?? ''} — ${next}`, true);
+    }
+    const granted = Array.isArray(body.key?.scopes) ? body.key.scopes.filter((x) => typeof x === 'string') : [];
+    return { secret: body.secret, name: typeof body.key?.name === 'string' ? body.key.name : 'funtools', scopes: granted };
+}

package/dist/keys/store.js

@@ -0,0 +1,167 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+export const KEY_SHAPE = /^fp_live_[A-Za-z0-9_-]{16,}$/;
+const ACCOUNT = /^[A-Za-z0-9._:[\]-]{1,255}$/;
+export const DEFAULT_API = 'https://api.funpixel.ai';
+const stateHome = () => process.env.FUNPIXEL_STATE_HOME || homedir();
+export const apiUrlFile = (home = stateHome()) => join(home, '.funpixel', 'api-url');
+export function apiUrl(home = stateHome()) {
+    if (process.env.FUNPIXEL_API_URL)
+        return process.env.FUNPIXEL_API_URL;
+    try {
+        const saved = existsSync(apiUrlFile(home)) ? readFileSync(apiUrlFile(home), 'utf8').trim() : '';
+        if (/^https?:\/\/\S+$/.test(saved))
+            return saved;
+    }
+    catch { }
+    return DEFAULT_API;
+}
+export function saveApiUrl(url, home = stateHome()) {
+    const file = apiUrlFile(home);
+    if (url.replace(/\/$/, '') === DEFAULT_API) {
+        rmSync(file, { force: true });
+        return;
+    }
+    mkdirSync(join(home, '.funpixel'), { recursive: true });
+    writeFileSync(file, url.replace(/\/$/, '') + '\n');
+}
+export function apiHost() {
+    const raw = apiUrl();
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        throw new Error('FUNPIXEL_API_URL is not a URL');
+    }
+    if (!/^https?:$/.test(url.protocol) || !ACCOUNT.test(url.host))
+        throw new Error('FUNPIXEL_API_URL must be a plain http(s) URL');
+    return url.host;
+}
+function guarded(store) {
+    const account = (a) => {
+        if (!ACCOUNT.test(a))
+            throw new Error(`not a usable account name: ${JSON.stringify(a)}`);
+        return a;
+    };
+    return {
+        name: store.name,
+        get: (a) => store.get(account(a)),
+        set: (a, key) => {
+            if (!KEY_SHAPE.test(key))
+                throw new Error('that is not an fp_live_ key');
+            store.set(account(a), key);
+        },
+        remove: (a) => store.remove(account(a)),
+    };
+}
+function run(cmd, args, input) {
+    const r = spawnSync(cmd, args, { input, encoding: 'utf8', timeout: 30_000, windowsHide: true });
+    return { ok: r.status === 0 && !r.error, out: (r.stdout ?? '').trim(), code: r.status };
+}
+function keychain(service) {
+    return {
+        name: 'the macOS Keychain',
+        get(account) {
+            const r = run('/usr/bin/security', ['find-generic-password', '-s', service, '-a', account, '-w']);
+            return r.ok && r.out ? r.out : null;
+        },
+        set(account, key) {
+            const r = run('/usr/bin/security', ['-i'], `add-generic-password -U -s ${service} -a ${account} -w ${key}\n`);
+            if (!r.ok || this.get(account) !== key)
+                throw new Error('the Keychain refused the key');
+        },
+        remove(account) {
+            return run('/usr/bin/security', ['delete-generic-password', '-s', service, '-a', account]).ok;
+        },
+    };
+}
+function libsecret(service) {
+    return {
+        name: 'the Secret Service (libsecret)',
+        get(account) {
+            const r = run('secret-tool', ['lookup', 'service', service, 'account', account]);
+            return r.ok && r.out ? r.out : null;
+        },
+        set(account, key) {
+            const r = run('secret-tool', ['store', `--label=Funpixel API key (${account})`, 'service', service, 'account', account], key);
+            if (!r.ok)
+                throw new Error('secret-tool could not store the key — is a keyring (gnome-keyring, KeePassXC) running?');
+        },
+        remove(account) {
+            const had = this.get(account) !== null;
+            return run('secret-tool', ['clear', 'service', service, 'account', account]).ok && had;
+        },
+    };
+}
+const CRED_TYPES = `
+using System; using System.Runtime.InteropServices; using System.Text;
+using FILETIME = System.Runtime.InteropServices.ComTypes.FILETIME;
+public static class FpCred {
+  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+  public struct CREDENTIAL { public int Flags; public int Type; public string TargetName; public string Comment;
+    public FILETIME LastWritten; public int CredentialBlobSize; public IntPtr CredentialBlob; public int Persist;
+    public int AttributeCount; public IntPtr Attributes; public string TargetAlias; public string UserName; }
+  [DllImport("advapi32", CharSet = CharSet.Unicode, SetLastError = true)] static extern bool CredRead(string t, int type, int flags, out IntPtr c);
+  [DllImport("advapi32", CharSet = CharSet.Unicode, SetLastError = true)] static extern bool CredWrite(ref CREDENTIAL c, int flags);
+  [DllImport("advapi32", CharSet = CharSet.Unicode, SetLastError = true)] static extern bool CredDelete(string t, int type, int flags);
+  [DllImport("advapi32")] static extern void CredFree(IntPtr c);
+  public static string Read(string t) {
+    IntPtr p; if (!CredRead(t, 1, 0, out p)) return null;
+    try { var c = (CREDENTIAL)Marshal.PtrToStructure(p, typeof(CREDENTIAL)); return Marshal.PtrToStringUni(c.CredentialBlob, c.CredentialBlobSize / 2); }
+    finally { CredFree(p); }
+  }
+  public static bool Write(string t, string secret) {
+    var b = Encoding.Unicode.GetBytes(secret);
+    var c = new CREDENTIAL { Type = 1, TargetName = t, UserName = "funpixel", CredentialBlobSize = b.Length, Persist = 2 };
+    c.CredentialBlob = Marshal.AllocHGlobal(b.Length);
+    try { Marshal.Copy(b, 0, c.CredentialBlob, b.Length); return CredWrite(ref c, 0); } finally { Marshal.FreeHGlobal(c.CredentialBlob); }
+  }
+  public static bool Delete(string t) { return CredDelete(t, 1, 0); }
+}`;
+function credentialManager(service) {
+    const ps = (body, input) => {
+        const script = `$ErrorActionPreference='Stop'; Add-Type -TypeDefinition @'\n${CRED_TYPES}\n'@; ${body}`;
+        const encoded = Buffer.from(script, 'utf16le').toString('base64');
+        return run('powershell.exe', ['-NoProfile', '-NonInteractive', '-EncodedCommand', encoded], input);
+    };
+    const target = (account) => `${service}:${account}`;
+    return {
+        name: 'Windows Credential Manager',
+        get(account) {
+            const r = ps(`$v = [FpCred]::Read('${target(account)}'); if ($v) { [Console]::Out.Write($v) }`);
+            return r.ok && r.out ? r.out : null;
+        },
+        set(account, key) {
+            const r = ps(`$k = [Console]::In.ReadLine(); if (-not [FpCred]::Write('${target(account)}', $k)) { exit 1 }`, `${key}\n`);
+            if (!r.ok)
+                throw new Error('Credential Manager refused the key');
+        },
+        remove(account) {
+            return ps(`if (-not [FpCred]::Delete('${target(account)}')) { exit 1 }`).ok;
+        },
+    };
+}
+const has = (cmd) => spawnSync(cmd, ['--version'], { stdio: 'ignore', timeout: 10_000 }).error === undefined;
+export function osStore(service = 'funpixel', platform = process.platform) {
+    if (process.env.FUNPIXEL_KEY_STORE === 'none')
+        return null;
+    if (platform === 'darwin')
+        return guarded(keychain(service));
+    if (platform === 'win32')
+        return guarded(credentialManager(service));
+    return has('secret-tool') ? guarded(libsecret(service)) : null;
+}
+export function apiKey(store = osStore()) {
+    const env = process.env.FUNPIXEL_API_KEY?.trim();
+    if (env)
+        return env;
+    try {
+        return store?.get(apiHost()) ?? null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/lanes/fence.js

@@ -0,0 +1,108 @@
+import { existsSync, readFileSync, realpathSync } from 'node:fs';
+import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { LANES_FILE, laneGame, owned, readLanes } from "./lanes.js";
+import { hasUnion, unionOnlyChange } from "./union.js";
+const T = 'npx @funpixel/tools';
+export const WRITE_TOOLS = /^(Write|Edit|MultiEdit|NotebookEdit)$/;
+const FREE = /^(\.funtools\/|node_modules(\/|$)|dist\/|verify\.json$)/;
+export const isLaneAgent = (agentType) => /(^|[:/-])lane$/i.test(String(agentType ?? ''));
+function real(p) {
+    let head = resolve(p);
+    const rest = [];
+    for (;;) {
+        try {
+            return join(realpathSync(head), ...[...rest].reverse());
+        }
+        catch { }
+        const up = dirname(head);
+        if (up === head)
+            return resolve(p);
+        rest.push(head.slice(up.length).replace(/^[\\/]/, ''));
+        head = up;
+    }
+}
+const within = (dir, p) => { const r = relative(dir, p); return r === '' || (!r.startsWith('..') && !isAbsolute(r)); };
+export function lanesHome(p) {
+    for (let d = real(p);; d = dirname(d)) {
+        const f = existsSync(join(d, LANES_FILE)) ? readLanes(d) : null;
+        if (f)
+            return { home: d, f };
+        if (dirname(d) === d)
+            return null;
+    }
+}
+export function laneAt(p) {
+    const h = lanesHome(p);
+    if (!h)
+        return null;
+    const abs = real(p);
+    const lane = h.f.lanes.find((l) => l.worktree && within(real(join(h.home, l.worktree)), abs));
+    return lane ? { ...h, lane, rel: relative(real(laneGame(h.home, lane)), abs).split(sep).join('/') } : null;
+}
+export function fence(c) {
+    if (!WRITE_TOOLS.test(c.tool))
+        return null;
+    const raw = c.input.file_path ?? c.input.notebook_path;
+    if (typeof raw !== 'string' || !raw)
+        return null;
+    const target = resolve(c.cwd, raw);
+    const mine = laneAt(c.cwd);
+    if (!mine && !isLaneAgent(c.agentType))
+        return null;
+    const at = laneAt(target);
+    const who = (l) => (l ? `Lane ${l.id}` : 'A lane agent');
+    if (!at) {
+        const h = mine ?? lanesHome(target);
+        if (!h || !within(real(h.home), real(target)))
+            return null;
+        const where = mine ? `its checkout, ${mine.lane.worktree}/` : 'the checkout its brief names (.funtools/worktrees/<id>/)';
+        return { deny: `${who(mine?.lane)} writes only inside ${where}; ${relative(real(h.home), real(target)).split(sep).join('/')} is in the integrator's game folder. Refused; reads stay free. Make the change in your checkout, or note it for the integrator: \`${T} lanes checkpoint <id> --line "needs …"\`.` };
+    }
+    if (mine && mine.lane.id !== at.lane.id)
+        return { deny: `Lane ${mine.lane.id} writes only inside its own checkout; ${raw} is in lane ${at.lane.id}'s checkout (${at.lane.worktree}/). Refused; reads stay free. Note what you need for lane ${at.lane.id} or the integrator: \`${T} lanes checkpoint ${mine.lane.id} --line "needs …"\`.` };
+    const lane = at.lane;
+    const owns = Array.isArray(lane.owns) ? lane.owns : [];
+    if (at.rel.startsWith('..'))
+        return { deny: `Lane ${lane.id} writes only inside its game folder; ${raw} is elsewhere in the repository (the integrator's). Refused; reads stay free.` };
+    if (FREE.test(at.rel))
+        return null;
+    if (!owns.length)
+        return { note: `Lane ${lane.id} declares no paths in ${LANES_FILE} ("owns"), so its writes are not fenced; the gate still judges what it changed.`, lane: lane.id };
+    if (owned(owns, at.rel))
+        return null;
+    const before = readText(target);
+    if (unionOnlyChange(before, after(c, before)))
+        return null;
+    const owner = at.f.lanes.find((l) => l.id !== lane.id && Array.isArray(l.owns) && owned(l.owns, at.rel))?.id;
+    return {
+        deny: [
+            `Lane ${lane.id} owns only ${owns.map((g) => `\`${g}\``).join(', ')}; \`${at.rel}\` is not one of them (${owner ? `lane ${owner}'s` : "the integrator's"}). Refused; reading it stays free.`,
+            ...(before !== null && hasUnion(before) ? [`It has an \`fp:union\` block: add or change your one line inside the block and nothing else, and that write goes through.`] : []),
+            `Instead: work around it, and note the change you need for ${owner ? `lane ${owner}` : 'the integrator'}: \`${T} lanes checkpoint ${lane.id} --line "needs ${at.rel}: <the change>"\`, or ask the lead.`,
+        ].join(' '),
+    };
+}
+function readText(p) {
+    try {
+        return readFileSync(p, 'utf8');
+    }
+    catch {
+        return null;
+    }
+}
+function after(c, before) {
+    const i = c.input;
+    if (c.tool === 'Write')
+        return typeof i.content === 'string' ? i.content : '';
+    if (before === null)
+        return '';
+    const edits = c.tool === 'Edit' ? [i] : c.tool === 'MultiEdit' && Array.isArray(i.edits) ? i.edits : [];
+    let text = before;
+    for (const e of edits) {
+        const from = e.old_string, to = e.new_string;
+        if (typeof from !== 'string' || typeof to !== 'string' || !from || !text.includes(from))
+            return '';
+        text = e.replace_all ? text.split(from).join(to) : text.replace(from, () => to);
+    }
+    return edits.length ? text : '';
+}

package/dist/lanes/gate.js

@@ -0,0 +1,123 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { npmTest } from "../commands/test.js";
+import { fingerprint } from "../verify/fingerprint.js";
+import { evaluateGate, momentScores, readPipeline, defaultPipeline } from "../pipeline/pipeline.js";
+import { LOOK_FLOOR, laneGame, outside, readMaking } from "./lanes.js";
+import { unionOnlyChange } from "./union.js";
+const T = 'npx @funpixel/tools';
+export const git = (args, cwd) => {
+    const r = spawnSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+    return { ok: r.status === 0, out: (r.stdout ?? '').replace(/^\n+/, '').trimEnd(), err: (r.stderr ?? '').trim() };
+};
+export const BIN = fileURLToPath(new URL(import.meta.url.endsWith('.ts') ? '../bin.ts' : '../bin.js', import.meta.url));
+export const headOf = (dir) => { const r = git(['rev-parse', 'HEAD'], dir); return r.ok ? r.out : null; };
+export const branchOf = (dir) => { const r = git(['rev-parse', '--abbrev-ref', 'HEAD'], dir); return r.ok ? r.out : 'HEAD'; };
+export function laneChanges(home, wt, prefix = '') {
+    const homeHead = headOf(home);
+    const mb = homeHead ? git(['merge-base', homeHead, 'HEAD'], wt) : { ok: false, out: '' };
+    const base = mb.ok ? mb.out : null;
+    const diff = base ? git(['diff', '--name-only', '--relative', `${base}..HEAD`], wt) : { ok: false, out: '' };
+    const changed = diff.ok ? diff.out.split('\n').filter(Boolean) : [];
+    const st = git(['status', '--porcelain', '--untracked-files=all', '--', '.'], wt);
+    const dirty = (st.ok ? st.out.split('\n').filter(Boolean) : []).map((l) => l.slice(3).replace(/^"|"$/g, '')).filter((p) => p.startsWith(prefix)).map((p) => p.slice(prefix.length))
+        .filter((p) => !p.startsWith('.funtools/') && !p.startsWith('node_modules') && !p.startsWith('dist/') && p !== 'verify.json');
+    return { changed, dirty, base };
+}
+function run(cmd, cwd) {
+    const r = spawnSync(cmd, { cwd, shell: true, encoding: 'utf8', timeout: 15 * 60_000, env: { ...process.env, NODE_TEST_CONTEXT: undefined } });
+    const tail = `${r.stdout ?? ''}\n${r.stderr ?? ''}`.trim().split('\n').slice(-4).join(' / ');
+    return { code: r.status ?? 1, tail };
+}
+export async function runGate(home, f, lane, o = {}) {
+    const wt = laneGame(home, lane);
+    const sha = headOf(wt) ?? '';
+    const checks = [];
+    const add = (g, state, says, runCmd) => checks.push({ kind: g.kind, name: g.kind === 'command' ? (g.name ?? g.run ?? 'command') : g.kind, state, says, ...(runCmd ? { run: runCmd } : {}) });
+    const homeHead = headOf(home);
+    for (const g of lane.gates) {
+        switch (g.kind) {
+            case 'synced': {
+                const ok = !!homeHead && git(['merge-base', '--is-ancestor', homeHead, 'HEAD'], wt).ok;
+                add(g, ok ? 'pass' : 'fail', ok ? 'the landed work is in this lane' : 'the game\'s branch moved since this lane left it: take the landed work first', ok ? undefined : `${T} lanes sync ${lane.id}`);
+                break;
+            }
+            case 'owns': {
+                const { changed, dirty, base } = laneChanges(home, wt, lane.prefix ?? '');
+                const shown = (rev, p) => { const r = git(['show', `${rev}:./${p}`], wt); return r.ok ? r.out : null; };
+                const out = outside(f, lane, changed).filter((x) => !(base && unionOnlyChange(shown(base, x.path), shown('HEAD', x.path) ?? '')));
+                if (dirty.length)
+                    add(g, 'fail', `uncommitted: ${dirty.slice(0, 5).join(', ')}${dirty.length > 5 ? '…' : ''} (the gate judges commits)`, 'commit your own paths (git add <path>; git commit)');
+                else if (out.length)
+                    add(g, 'fail', `changed outside what it owns: ${out.slice(0, 5).map((x) => `${x.path}${x.owner ? ` (lane ${x.owner}'s)` : ' (the integrator\'s)'}`).join(', ')}`, 'revert those files on the lane (git checkout <base> -- <path>; commit), and ask the owning lane or the integrator in a checkpoint');
+                else if (!changed.length)
+                    add(g, 'fail', 'no commit on the lane yet', 'commit your work in the checkout');
+                else
+                    add(g, 'pass', `${changed.length} file(s), all its own`);
+                break;
+            }
+            case 'tests': {
+                if (!existsSync(join(wt, 'package.json'))) {
+                    add(g, 'not_observed', 'no package.json in the checkout');
+                    break;
+                }
+                const code = await npmTest(wt, false, true);
+                add(g, code === 0 ? 'pass' : 'fail', code === 0 ? 'npm test exits 0' : `npm test exits ${code}`, code === 0 ? undefined : 'npm test in the checkout; fix what fails');
+                break;
+            }
+            case 'sim': {
+                if (!existsSync(join(wt, 'test', 'probes.ts'))) {
+                    add(g, 'not_observed', 'no test/probes.ts: the bots have nothing to play', 'write the GDD\'s bots in test/probes.ts (skill funpixel-game-logic)');
+                    break;
+                }
+                const r = run(`"${process.execPath}" "${BIN}" sim .`, wt);
+                const fp = (await fingerprint(wt).catch(() => null))?.fingerprint ?? null;
+                const p = readPipeline(wt) ?? defaultPipeline('small');
+                const own = p.stages.find((x) => x.id === lane.stage)?.gates.find((x) => x.kind === 'sim') ?? p.stages.flatMap((x) => x.gates).find((x) => x.kind === 'sim');
+                const e = evaluateGate(wt, own ?? { kind: 'sim' }, fp, p, lane.stage);
+                add(g, e.state === 'met' ? 'pass' : e.state === 'failing' ? 'fail' : 'not_observed', e.state === 'met' ? e.says : `${e.says}${r.code > 1 ? ` (sim exit ${r.code}: ${r.tail.slice(0, 120)})` : ''}`, e.state === 'met' ? undefined : e.run);
+                break;
+            }
+            case 'look': {
+                const min = g.min ?? LOOK_FLOOR;
+                let raw = null;
+                try {
+                    raw = JSON.parse(readFileSync(join(wt, 'design', 'look', 'scores.json'), 'utf8'));
+                }
+                catch { }
+                const fp = (await fingerprint(wt).catch(() => null))?.fingerprint ?? null;
+                if (!raw) {
+                    add(g, 'not_observed', 'no frame scored beside its target on the lane\'s files (not scored is not a pass)', `${T} score --target`);
+                    break;
+                }
+                if (fp && raw.fingerprint && raw.fingerprint !== fp) {
+                    add(g, 'not_observed', 'the scores are from older files', `${T} score --target`);
+                    break;
+                }
+                const s = momentScores(raw).filter((m) => !g.frames?.length || g.frames.includes(m.moment));
+                if (!s.length) {
+                    add(g, 'not_observed', 'no owned moment scored', `${T} score --target`);
+                    break;
+                }
+                const low = s.filter((m) => m.score < min);
+                add(g, low.length ? 'fail' : 'pass', low.length ? `${low.length} of ${s.length} under ${min}: ${low.map((m) => `${m.moment} ${m.score}`).join(', ')}` : `every owned frame at ${min}+ (${s.map((m) => `${m.moment} ${m.score}`).join(', ')}; 90 is the stretch)`, low.length ? 'fix the biggest named gap, capture at the same framing, score again' : undefined);
+                break;
+            }
+            case 'command': {
+                const r = run(g.run ?? 'false', wt);
+                add(g, r.code === 0 ? 'pass' : 'fail', r.code === 0 ? `\`${g.run}\` exits 0` : `\`${g.run}\` exits ${r.code}: ${r.tail.slice(0, 160)}`, r.code === 0 ? undefined : g.run);
+                break;
+            }
+            case 'report': {
+                const n = readMaking(home, lane.id).filter((e) => e.kind === 'checkpoint' || e.kind === 'final').length;
+                add(g, n ? 'pass' : 'fail', n ? `${n} checkpoint(s)` : 'no checkpoint: the making-of has nothing from the lane', `${T} lanes checkpoint ${lane.id} --line "<what you tried>"`);
+                break;
+            }
+            case 'verifier':
+            case 'pick': break;
+        }
+    }
+    return { sha, at: (o.now ?? new Date()).toISOString(), passed: checks.every((c) => c.state === 'pass'), checks };
+}