@north-light/crouter 0.3.318 → 0.3.319

package/dist/core/keybindings/resolve.js

@@ -1,348 +1 @@
-import { isDeepStrictEqual } from 'node:util';
-import { BINDING_CATALOG, BINDING_IDS, SAFETY_REQUIREMENTS } from './catalog.js';
-import { normalizeTmuxPassthrough, readRawScopeConfig } from '../config.js';
-const MODIFIER_ORDER = ['ctrl', 'alt', 'shift'];
-const INPUT_MODIFIERS = new Set(['ctrl', 'alt', 'shift', 'meta']);
-const NAMED_KEYS = new Set([
-    'enter', 'escape', 'tab', 'backspace', 'delete', 'space', 'up', 'down',
-    'left', 'right', 'pageup', 'pagedown', 'home', 'end',
-]);
-const KEY_ALIASES = { return: 'enter', esc: 'escape' };
-export class GestureSyntaxError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'GestureSyntaxError';
-    }
-}
-function tmuxNotation(value) {
-    const match = value.match(/^((?:[CMS]-)+)(.+)$/i);
-    if (match === null)
-        return value;
-    const modifiers = match[1].split('-').filter(Boolean).map((token) => {
-        if (token.toUpperCase() === 'C')
-            return 'ctrl';
-        if (token.toUpperCase() === 'M')
-            return 'alt';
-        return 'shift';
-    });
-    return `${modifiers.join('+')}+${match[2]}`;
-}
-export function normalizeStroke(raw) {
-    const value = tmuxNotation(raw.trim());
-    if (value === '')
-        throw new GestureSyntaxError('a stroke cannot be empty');
-    let rawKey;
-    let modifierParts;
-    if (value === '+') {
-        rawKey = '+';
-        modifierParts = [];
-    }
-    else if (value.endsWith('++')) {
-        rawKey = '+';
-        modifierParts = value.slice(0, -2).split('+');
-    }
-    else {
-        const parts = value.split('+');
-        if (parts.some((part) => part === ''))
-            throw new GestureSyntaxError(`invalid stroke "${raw}"`);
-        rawKey = parts.pop();
-        modifierParts = parts;
-    }
-    const inputModifiers = modifierParts.map((part) => part.toLowerCase());
-    if (inputModifiers.some((modifier) => !INPUT_MODIFIERS.has(modifier))) {
-        throw new GestureSyntaxError(`unsupported modifier in "${raw}"`);
-    }
-    const modifiers = inputModifiers.map((modifier) => modifier === 'meta' ? 'alt' : modifier);
-    if (new Set(modifiers).size !== modifiers.length) {
-        throw new GestureSyntaxError(`duplicate modifier in "${raw}"`);
-    }
-    let key = KEY_ALIASES[rawKey.toLowerCase()] ?? rawKey;
-    if (key.length === 1 && key >= 'A' && key <= 'Z') {
-        key = key.toLowerCase();
-        if (!modifiers.includes('shift'))
-            modifiers.push('shift');
-    }
-    else if (key.length !== 1) {
-        key = key.toLowerCase();
-    }
-    if (!(key.length === 1 && key.charCodeAt(0) >= 32 && key.charCodeAt(0) <= 126) && !NAMED_KEYS.has(key)) {
-        throw new GestureSyntaxError(`unsupported key "${rawKey}"`);
-    }
-    const ordered = MODIFIER_ORDER.filter((modifier) => modifiers.includes(modifier));
-    return [...ordered, key].join('+');
-}
-/**
- * Split a binding expression into its gesture list. A comma separates gestures
- * only when it stands between two non-empty gestures; a comma with nothing on
- * one side is the comma KEY itself, so `,` is bindable and `, , c` reads as the
- * comma key plus `c`. This mirrors the sequence separator `>`, which is only a
- * separator when surrounded by strokes.
- */
-export function splitGestureExpression(expression) {
-    const gestures = [];
-    let current = '';
-    for (let index = 0; index < expression.length; index += 1) {
-        const char = expression[index];
-        if (char !== ',') {
-            current += char;
-            continue;
-        }
-        const isSeparator = current.trim() !== '' && expression.slice(index + 1).trim() !== '';
-        if (isSeparator) {
-            gestures.push(current);
-            current = '';
-        }
-        else {
-            current += char;
-        }
-    }
-    gestures.push(current);
-    return gestures;
-}
-export function normalizeGesture(raw, definition) {
-    const parts = raw.trim().split(/\s+>\s+/);
-    if (parts.length > 2)
-        throw new GestureSyntaxError('a gesture may contain at most two strokes');
-    const normalized = parts.map(normalizeStroke);
-    if (normalized.length === 2 && definition?.inputKind !== 'tmux-sequence') {
-        throw new GestureSyntaxError('two-stroke sequences are supported only by tmux sequence actions');
-    }
-    if (definition?.inputKind === 'tmux-sequence' && normalized.length !== 2) {
-        throw new GestureSyntaxError('this action requires a two-stroke tmux sequence');
-    }
-    if (definition?.inputKind === 'tmux-menu-selector') {
-        if (normalized.length !== 1)
-            throw new GestureSyntaxError('a menu selector must be one stroke');
-        const stroke = normalized[0];
-        const pieces = stroke.split('+');
-        const key = pieces.at(-1);
-        const modifiers = pieces.slice(0, -1);
-        if ((key.length !== 1 && key !== 'space') || modifiers.some((modifier) => modifier !== 'shift')) {
-            throw new GestureSyntaxError('a menu selector must be one printable character');
-        }
-    }
-    if (definition?.inputKind === 'tmux-global-action') {
-        if (normalized.length !== 1)
-            throw new GestureSyntaxError('a global menu shortcut must be one stroke');
-        const modifiers = normalized[0].split('+').slice(0, -1);
-        if (!modifiers.includes('ctrl') && !modifiers.includes('alt')) {
-            throw new GestureSyntaxError('a global menu shortcut must include Ctrl or Alt');
-        }
-    }
-    return normalized.join(' > ');
-}
-function normalizeList(raw, definition) {
-    if (!Array.isArray(raw))
-        throw new GestureSyntaxError('the override must be an array of gesture strings');
-    const normalized = [];
-    for (const item of raw) {
-        if (typeof item !== 'string')
-            throw new GestureSyntaxError('every override entry must be a gesture string');
-        const gesture = normalizeGesture(item, definition);
-        if (!normalized.includes(gesture))
-            normalized.push(gesture);
-    }
-    return Object.freeze(normalized);
-}
-function contextsOverlap(a, b) {
-    return a.contexts.some((context) => b.contexts.includes(context));
-}
-function isTmuxRoot(definition) {
-    return definition.contexts.includes('tmux.root');
-}
-function isInPane(definition) {
-    return !isTmuxRoot(definition)
-        && definition.inputKind !== 'tmux-menu-selector'
-        && definition.inputKind !== 'tmux-sequence';
-}
-function firstStroke(gesture) {
-    return gesture.split(' > ')[0];
-}
-function gesturesConflict(leftDefinition, leftGesture, rightDefinition, rightGesture) {
-    const leftSequence = leftGesture.includes(' > ');
-    const rightSequence = rightGesture.includes(' > ');
-    if (contextsOverlap(leftDefinition, rightDefinition)) {
-        if (leftSequence && rightSequence)
-            return leftGesture === rightGesture;
-        if (leftSequence || rightSequence)
-            return firstStroke(leftGesture) === firstStroke(rightGesture);
-        return leftGesture === rightGesture;
-    }
-    const leftRoot = isTmuxRoot(leftDefinition);
-    const rightRoot = isTmuxRoot(rightDefinition);
-    if (!leftRoot && !rightRoot)
-        return false;
-    if (leftRoot && rightRoot && leftSequence && rightSequence)
-        return leftGesture === rightGesture;
-    if (leftRoot && rightRoot)
-        return firstStroke(leftGesture) === firstStroke(rightGesture);
-    if (leftRoot && isInPane(rightDefinition))
-        return firstStroke(leftGesture) === rightGesture;
-    if (rightRoot && isInPane(leftDefinition))
-        return leftGesture === firstStroke(rightGesture);
-    return false;
-}
-function defaultGestures(definition) {
-    return Object.freeze(definition.defaults.map((gesture) => normalizeGesture(gesture, definition)));
-}
-class FrozenBindingMap {
-    #map;
-    constructor(entries) { this.#map = new Map(entries); }
-    get size() { return this.#map.size; }
-    get(key) { return this.#map.get(key); }
-    has(key) { return this.#map.has(key); }
-    entries() { return this.#map.entries(); }
-    keys() { return this.#map.keys(); }
-    values() { return this.#map.values(); }
-    forEach(callbackfn, thisArg) {
-        for (const [key, value] of this.#map)
-            callbackfn.call(thisArg, value, key, this);
-    }
-    [Symbol.iterator]() { return this.#map[Symbol.iterator](); }
-}
-function diagnostic(code, message, offendingValue, bindingId, relatedBindingIds) {
-    return Object.freeze({ severity: 'error', code, message, offendingValue, ...(bindingId ? { bindingId } : {}), ...(relatedBindingIds ? { relatedBindingIds: Object.freeze([...relatedBindingIds]) } : {}) });
-}
-function collisionPairs(records) {
-    const out = [];
-    for (let leftIndex = 0; leftIndex < records.length; leftIndex += 1) {
-        const left = records[leftIndex];
-        for (let rightIndex = leftIndex + 1; rightIndex < records.length; rightIndex += 1) {
-            const right = records[rightIndex];
-            for (const leftGesture of left.gestures) {
-                const conflict = right.gestures.find((rightGesture) => gesturesConflict(left.definition, leftGesture, right.definition, rightGesture));
-                if (conflict !== undefined) {
-                    out.push([left, right, leftGesture.includes(' > ') ? leftGesture : conflict]);
-                    break;
-                }
-            }
-        }
-    }
-    return out;
-}
-function requirementSatisfied(records, context, capability) {
-    return records.some((record) => record.definition.safety === capability
-        && record.gestures.length > 0
-        && record.definition.contexts.includes(context));
-}
-function rejectCollidingUserOverrides(records, diagnostics) {
-    while (true) {
-        const rejected = new Set();
-        for (const [left, right, gesture] of collisionPairs(records)) {
-            if (left.source === 'user')
-                rejected.add(left);
-            if (right.source === 'user')
-                rejected.add(right);
-            if (left.source === 'default' && right.source === 'default') {
-                throw new Error(`keybinding catalog default collision: ${left.definition.id} / ${right.definition.id} (${gesture})`);
-            }
-            diagnostics.push(diagnostic('collision', `${left.definition.id} and ${right.definition.id} both claim ${gesture} in overlapping contexts`, gesture, left.source === 'user' ? left.definition.id : right.definition.id, [left.definition.id, right.definition.id]));
-        }
-        if (rejected.size === 0)
-            return;
-        for (const record of rejected) {
-            record.gestures = defaultGestures(record.definition);
-            record.source = 'default';
-        }
-    }
-}
-export function resolveKeybindings(rawOverrides = undefined) {
-    const diagnostics = [];
-    let overrides = {};
-    if (rawOverrides !== undefined) {
-        if (rawOverrides === null || typeof rawOverrides !== 'object' || Array.isArray(rawOverrides)) {
-            diagnostics.push(diagnostic('invalid-keybindings', 'keybindings must be an object keyed by catalog binding ID', rawOverrides));
-        }
-        else {
-            overrides = rawOverrides;
-        }
-    }
-    for (const [id, value] of Object.entries(overrides)) {
-        if (!BINDING_IDS.has(id)) {
-            diagnostics.push(diagnostic('unknown-binding', `unknown keybinding ID: ${id}`, value, id));
-        }
-    }
-    const records = BINDING_CATALOG.map((definition) => {
-        const defaults = defaultGestures(definition);
-        if (!Object.hasOwn(overrides, definition.id))
-            return { definition, gestures: defaults, source: 'default' };
-        const rawOverride = overrides[definition.id];
-        try {
-            return { definition, gestures: normalizeList(rawOverride, definition), source: 'user', rawOverride };
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            diagnostics.push(diagnostic('invalid-override', `${definition.id}: ${message}`, rawOverride, definition.id));
-            return { definition, gestures: defaults, source: 'default' };
-        }
-    });
-    rejectCollidingUserOverrides(records, diagnostics);
-    for (const requirement of SAFETY_REQUIREMENTS) {
-        if (requirementSatisfied(records, requirement.context, requirement.capability))
-            continue;
-        const offenders = records.filter((record) => record.source === 'user'
-            && record.definition.safety === requirement.capability
-            && record.definition.contexts.includes(requirement.context));
-        diagnostics.push(diagnostic('unreachable', `${requirement.context} must retain an enabled ${requirement.capability} binding`, offenders.map((record) => record.rawOverride), offenders[0]?.definition.id, offenders.map((record) => record.definition.id)));
-        for (const offender of offenders) {
-            offender.gestures = defaultGestures(offender.definition);
-            offender.source = 'default';
-        }
-    }
-    rejectCollidingUserOverrides(records, diagnostics);
-    const entries = records.map((record) => {
-        const effective = Object.freeze({
-            definition: record.definition,
-            gestures: record.gestures,
-            source: record.source,
-        });
-        return [record.definition.id, effective];
-    });
-    const bindings = new FrozenBindingMap(entries);
-    const result = {
-        bindings,
-        diagnostics: Object.freeze(diagnostics),
-        get(id) {
-            const found = bindings.get(id);
-            if (found === undefined)
-                throw new Error(`unknown crouter keybinding ID: ${id}`);
-            return found;
-        },
-        gestures(id) { return this.get(id).gestures; },
-    };
-    return Object.freeze(result);
-}
-/** Resolve keybindings and tmux passthrough from one immutable user-config snapshot. */
-export function resolveUserKeybindingSettings() {
-    const raw = readRawScopeConfig('user');
-    return Object.freeze({
-        bindings: resolveKeybindings(raw?.keybindings),
-        tmuxPassthrough: Object.freeze(normalizeTmuxPassthrough(raw?.tmux_passthrough)),
-    });
-}
-export function resolveUserKeybindings() {
-    return resolveUserKeybindingSettings().bindings;
-}
-export function normalizeSparseOverrides(rawOverrides) {
-    const resolved = resolveKeybindings(rawOverrides);
-    if (resolved.diagnostics.length > 0) {
-        throw new KeybindingValidationError(resolved.diagnostics);
-    }
-    const sparse = {};
-    for (const definition of BINDING_CATALOG) {
-        const effective = resolved.get(definition.id);
-        const defaults = defaultGestures(definition);
-        if (effective.source === 'user' && !isDeepStrictEqual(effective.gestures, defaults)) {
-            sparse[definition.id] = [...effective.gestures];
-        }
-    }
-    return sparse;
-}
-export class KeybindingValidationError extends Error {
-    diagnostics;
-    constructor(diagnostics) {
-        super(diagnostics[0]?.message ?? 'invalid keybindings');
-        this.name = 'KeybindingValidationError';
-        this.diagnostics = diagnostics;
-    }
-}
+var E=Object.defineProperty;var a=(n,e)=>E(n,"name",{value:e,configurable:!0});import{isDeepStrictEqual as v}from"node:util";import{BINDING_CATALOG as b,BINDING_IDS as z,SAFETY_REQUIREMENTS as $}from"./catalog.js";import{normalizeTmuxPassthrough as j,readRawScopeConfig as I}from"../config.js";const O=["ctrl","alt","shift"],C=new Set(["ctrl","alt","shift","meta"]),A=new Set(["enter","escape","tab","backspace","delete","space","up","down","left","right","pageup","pagedown","home","end"]),K={return:"enter",esc:"escape"};class l extends Error{static{a(this,"GestureSyntaxError")}constructor(e){super(e),this.name="GestureSyntaxError"}}function q(n){const e=n.match(/^((?:[CMS]-)+)(.+)$/i);return e===null?n:`${e[1].split("-").filter(Boolean).map(t=>t.toUpperCase()==="C"?"ctrl":t.toUpperCase()==="M"?"alt":"shift").join("+")}+${e[2]}`}a(q,"tmuxNotation");function R(n){const e=q(n.trim());if(e==="")throw new l("a stroke cannot be empty");let r,t;if(e==="+")r="+",t=[];else if(e.endsWith("++"))r="+",t=e.slice(0,-2).split("+");else{const o=e.split("+");if(o.some(f=>f===""))throw new l(`invalid stroke "${n}"`);r=o.pop(),t=o}const i=t.map(o=>o.toLowerCase());if(i.some(o=>!C.has(o)))throw new l(`unsupported modifier in "${n}"`);const c=i.map(o=>o==="meta"?"alt":o);if(new Set(c).size!==c.length)throw new l(`duplicate modifier in "${n}"`);let u=K[r.toLowerCase()]??r;if(u.length===1&&u>="A"&&u<="Z"?(u=u.toLowerCase(),c.includes("shift")||c.push("shift")):u.length!==1&&(u=u.toLowerCase()),!(u.length===1&&u.charCodeAt(0)>=32&&u.charCodeAt(0)<=126)&&!A.has(u))throw new l(`unsupported key "${r}"`);return[...O.filter(o=>c.includes(o)),u].join("+")}a(R,"normalizeStroke");function Q(n){const e=[];let r="";for(let t=0;t<n.length;t+=1){const i=n[t];if(i!==","){r+=i;continue}r.trim()!==""&&n.slice(t+1).trim()!==""?(e.push(r),r=""):r+=i}return e.push(r),e}a(Q,"splitGestureExpression");function w(n,e){const r=n.trim().split(/\s+>\s+/);if(r.length>2)throw new l("a gesture may contain at most two strokes");const t=r.map(R);if(t.length===2&&e?.inputKind!=="tmux-sequence")throw new l("two-stroke sequences are supported only by tmux sequence actions");if(e?.inputKind==="tmux-sequence"&&t.length!==2)throw new l("this action requires a two-stroke tmux sequence");if(e?.inputKind==="tmux-menu-selector"){if(t.length!==1)throw new l("a menu selector must be one stroke");const c=t[0].split("+"),u=c.at(-1),s=c.slice(0,-1);if(u.length!==1&&u!=="space"||s.some(o=>o!=="shift"))throw new l("a menu selector must be one printable character")}if(e?.inputKind==="tmux-global-action"){if(t.length!==1)throw new l("a global menu shortcut must be one stroke");const i=t[0].split("+").slice(0,-1);if(!i.includes("ctrl")&&!i.includes("alt"))throw new l("a global menu shortcut must include Ctrl or Alt")}return t.join(" > ")}a(w,"normalizeGesture");function M(n,e){if(!Array.isArray(n))throw new l("the override must be an array of gesture strings");const r=[];for(const t of n){if(typeof t!="string")throw new l("every override entry must be a gesture string");const i=w(t,e);r.includes(i)||r.push(i)}return Object.freeze(r)}a(M,"normalizeList");function N(n,e){return n.contexts.some(r=>e.contexts.includes(r))}a(N,"contextsOverlap");function g(n){return n.contexts.includes("tmux.root")}a(g,"isTmuxRoot");function y(n){return!g(n)&&n.inputKind!=="tmux-menu-selector"&&n.inputKind!=="tmux-sequence"}a(y,"isInPane");function d(n){return n.split(" > ")[0]}a(d,"firstStroke");function _(n,e,r,t){const i=e.includes(" > "),c=t.includes(" > ");if(N(n,r))return i&&c?e===t:i||c?d(e)===d(t):e===t;const u=g(n),s=g(r);return!u&&!s?!1:u&&s&&i&&c?e===t:u&&s?d(e)===d(t):u&&y(r)?d(e)===t:s&&y(n)?e===d(t):!1}a(_,"gesturesConflict");function h(n){return Object.freeze(n.defaults.map(e=>w(e,n)))}a(h,"defaultGestures");class D{static{a(this,"FrozenBindingMap")}#e;constructor(e){this.#e=new Map(e)}get size(){return this.#e.size}get(e){return this.#e.get(e)}has(e){return this.#e.has(e)}entries(){return this.#e.entries()}keys(){return this.#e.keys()}values(){return this.#e.values()}forEach(e,r){for(const[t,i]of this.#e)e.call(r,i,t,this)}[Symbol.iterator](){return this.#e[Symbol.iterator]()}}function p(n,e,r,t,i){return Object.freeze({severity:"error",code:n,message:e,offendingValue:r,...t?{bindingId:t}:{},...i?{relatedBindingIds:Object.freeze([...i])}:{}})}a(p,"diagnostic");function L(n){const e=[];for(let r=0;r<n.length;r+=1){const t=n[r];for(let i=r+1;i<n.length;i+=1){const c=n[i];for(const u of t.gestures){const s=c.gestures.find(o=>_(t.definition,u,c.definition,o));if(s!==void 0){e.push([t,c,u.includes(" > ")?u:s]);break}}}}return e}a(L,"collisionPairs");function U(n,e,r){return n.some(t=>t.definition.safety===r&&t.gestures.length>0&&t.definition.contexts.includes(e))}a(U,"requirementSatisfied");function x(n,e){for(;;){const r=new Set;for(const[t,i,c]of L(n)){if(t.source==="user"&&r.add(t),i.source==="user"&&r.add(i),t.source==="default"&&i.source==="default")throw new Error(`keybinding catalog default collision: ${t.definition.id} / ${i.definition.id} (${c})`);e.push(p("collision",`${t.definition.id} and ${i.definition.id} both claim ${c} in overlapping contexts`,c,t.source==="user"?t.definition.id:i.definition.id,[t.definition.id,i.definition.id]))}if(r.size===0)return;for(const t of r)t.gestures=h(t.definition),t.source="default"}}a(x,"rejectCollidingUserOverrides");function k(n=void 0){const e=[];let r={};n!==void 0&&(n===null||typeof n!="object"||Array.isArray(n)?e.push(p("invalid-keybindings","keybindings must be an object keyed by catalog binding ID",n)):r=n);for(const[s,o]of Object.entries(r))z.has(s)||e.push(p("unknown-binding",`unknown keybinding ID: ${s}`,o,s));const t=b.map(s=>{const o=h(s);if(!Object.hasOwn(r,s.id))return{definition:s,gestures:o,source:"default"};const f=r[s.id];try{return{definition:s,gestures:M(f,s),source:"user",rawOverride:f}}catch(m){const S=m instanceof Error?m.message:String(m);return e.push(p("invalid-override",`${s.id}: ${S}`,f,s.id)),{definition:s,gestures:o,source:"default"}}});x(t,e);for(const s of $){if(U(t,s.context,s.capability))continue;const o=t.filter(f=>f.source==="user"&&f.definition.safety===s.capability&&f.definition.contexts.includes(s.context));e.push(p("unreachable",`${s.context} must retain an enabled ${s.capability} binding`,o.map(f=>f.rawOverride),o[0]?.definition.id,o.map(f=>f.definition.id)));for(const f of o)f.gestures=h(f.definition),f.source="default"}x(t,e);const i=t.map(s=>{const o=Object.freeze({definition:s.definition,gestures:s.gestures,source:s.source});return[s.definition.id,o]}),c=new D(i),u={bindings:c,diagnostics:Object.freeze(e),get(s){const o=c.get(s);if(o===void 0)throw new Error(`unknown crouter keybinding ID: ${s}`);return o},gestures(s){return this.get(s).gestures}};return Object.freeze(u)}a(k,"resolveKeybindings");function P(){const n=I("user");return Object.freeze({bindings:k(n?.keybindings),tmuxPassthrough:Object.freeze(j(n?.tmux_passthrough))})}a(P,"resolveUserKeybindingSettings");function W(){return P().bindings}a(W,"resolveUserKeybindings");function Z(n){const e=k(n);if(e.diagnostics.length>0)throw new T(e.diagnostics);const r={};for(const t of b){const i=e.get(t.id),c=h(t);i.source==="user"&&!v(i.gestures,c)&&(r[t.id]=[...i.gestures])}return r}a(Z,"normalizeSparseOverrides");class T extends Error{static{a(this,"KeybindingValidationError")}diagnostics;constructor(e){super(e[0]?.message??"invalid keybindings"),this.name="KeybindingValidationError",this.diagnostics=e}}export{l as GestureSyntaxError,T as KeybindingValidationError,w as normalizeGesture,Z as normalizeSparseOverrides,R as normalizeStroke,k as resolveKeybindings,P as resolveUserKeybindingSettings,W as resolveUserKeybindings,Q as splitGestureExpression};

package/dist/core/keybindings/types.js

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

package/dist/core/locked-file.js

@@ -1,118 +1 @@
-// locked-file.ts — crouter's cross-process locked read/modify/write primitive for the
-// small JSON state files the runtime co-owns with pi: pi's own `auth.json` (api keys and
-// non-managed OAuth credentials) and crouter's per-provider subscription pool files, which
-// hold every managed account's own credential.
-//
-// The lock is `proper-lockfile` on the target path, so a crouter process and a pi process
-// contending for `auth.json` still exclude each other: same library, same lock path, and
-// same `realpath: false` option. Every callback runs asynchronously and returns
-// `{ result, next }`; `next === undefined` means "no write". Every write lands by atomic
-// tmp+rename (pool callers do their own, inside the callback), so a whole snapshot is the
-// only thing on disk and READS need no lock at all -- `readUnlocked` serves them. That
-// matters: pi asks its CredentialStore for every registered provider (~75) whenever it
-// builds a model runtime, and routing those through the lock made each boot serialize
-// behind seconds of lock acquisition backoff.
-import { chmodSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, writeFileSync, closeSync } from 'node:fs';
-import { dirname } from 'node:path';
-import lockfile from 'proper-lockfile';
-const WRITE_OPTIONS = { encoding: 'utf-8', mode: 0o600 };
-// proper-lockfile decides a held lock is abandoned when its lockdir mtime is older than
-// the acquirer's `stale`, and refreshes the mtime on the holder's `update` timer. The holder
-// refreshes well inside the staleness threshold so long-running callbacks remain protected.
-const LOCK_STALE_MS = 30_000;
-const LOCK_UPDATE_MS = 5_000;
-/** A 0600 JSON file guarded by a cross-process `proper-lockfile` lock on its own path. */
-export class LockedJsonFile {
-    path;
-    durable;
-    initialContent;
-    constructor(path, durable = false, initialContent = '{}') {
-        this.path = path;
-        this.durable = durable;
-        this.initialContent = initialContent;
-    }
-    readUnlocked() {
-        return existsSync(this.path) ? readFileSync(this.path, 'utf-8') : undefined;
-    }
-    ensureFile() {
-        const dir = dirname(this.path);
-        if (!existsSync(dir))
-            mkdirSync(dir, { recursive: true, mode: 0o700 });
-        if (!existsSync(this.path)) {
-            writeFileSync(this.path, this.initialContent, WRITE_OPTIONS);
-            chmodSync(this.path, 0o600);
-        }
-    }
-    /** Acquire the lock without blocking the event loop, keeping every read-modify-write
-     *  callback on the same asynchronous path. */
-    async withLockAsync(fn) {
-        this.ensureFile();
-        let release;
-        let compromised;
-        const throwIfCompromised = () => {
-            if (compromised)
-                throw compromised;
-        };
-        try {
-            release = await lockfile.lock(this.path, {
-                // A different realpath setting would derive a DIFFERENT lock path for a symlinked
-                // auth.json and silently stop excluding other writers.
-                realpath: false,
-                retries: { retries: 10, factor: 2, minTimeout: 100, maxTimeout: 10_000, randomize: true },
-                stale: LOCK_STALE_MS,
-                // Refresh the lockdir mtime well inside `stale` so long-running callbacks remain protected.
-                update: LOCK_UPDATE_MS,
-                onCompromised: (err) => {
-                    compromised = err;
-                },
-            });
-            throwIfCompromised();
-            const current = existsSync(this.path) ? readFileSync(this.path, 'utf-8') : undefined;
-            let published = false;
-            const publish = (next) => {
-                if (published)
-                    throw new Error(`locked file was published twice: ${this.path}`);
-                throwIfCompromised();
-                const tmp = `${this.path}.${process.pid}.${Date.now()}.tmp`;
-                writeFileSync(tmp, next, WRITE_OPTIONS);
-                chmodSync(tmp, 0o600);
-                if (this.durable) {
-                    const fd = openSync(tmp, 'r');
-                    try {
-                        fsyncSync(fd);
-                    }
-                    finally {
-                        closeSync(fd);
-                    }
-                }
-                renameSync(tmp, this.path);
-                if (this.durable) {
-                    const fd = openSync(dirname(this.path), 'r');
-                    try {
-                        fsyncSync(fd);
-                    }
-                    finally {
-                        closeSync(fd);
-                    }
-                }
-                published = true;
-            };
-            const { result, next } = await fn(current, throwIfCompromised, publish);
-            throwIfCompromised();
-            if (next !== undefined)
-                publish(next);
-            throwIfCompromised();
-            return result;
-        }
-        finally {
-            if (release) {
-                try {
-                    await release();
-                }
-                catch {
-                    // A compromised lock's release throws; the compromise itself already surfaced.
-                }
-            }
-        }
-    }
-}
+var T=Object.defineProperty;var r=(c,t)=>T(c,"name",{value:t,configurable:!0});import{chmodSync as f,existsSync as a,fsyncSync as u,mkdirSync as F,openSync as m,readFileSync as y,renameSync as L,writeFileSync as S,closeSync as w}from"node:fs";import{dirname as _}from"node:path";import x from"proper-lockfile";const b={encoding:"utf-8",mode:384},E=3e4,O=5e3;class K{static{r(this,"LockedJsonFile")}path;durable;initialContent;constructor(t,e=!1,i="{}"){this.path=t,this.durable=e,this.initialContent=i}readUnlocked(){return a(this.path)?y(this.path,"utf-8"):void 0}ensureFile(){const t=_(this.path);a(t)||F(t,{recursive:!0,mode:448}),a(this.path)||(S(this.path,this.initialContent,b),f(this.path,384))}async withLockAsync(t){this.ensureFile();let e,i;const s=r(()=>{if(i)throw i},"throwIfCompromised");try{e=await x.lock(this.path,{realpath:!1,retries:{retries:10,factor:2,minTimeout:100,maxTimeout:1e4,randomize:!0},stale:E,update:O,onCompromised:r(h=>{i=h},"onCompromised")}),s();const k=a(this.path)?y(this.path,"utf-8"):void 0;let l=!1;const d=r(h=>{if(l)throw new Error(`locked file was published twice: ${this.path}`);s();const o=`${this.path}.${process.pid}.${Date.now()}.tmp`;if(S(o,h,b),f(o,384),this.durable){const n=m(o,"r");try{u(n)}finally{w(n)}}if(L(o,this.path),this.durable){const n=m(_(this.path),"r");try{u(n)}finally{w(n)}}l=!0},"publish"),{result:C,next:p}=await t(k,s,d);return s(),p!==void 0&&d(p),s(),C}finally{if(e)try{await e()}catch{}}}}export{K as LockedJsonFile};

package/dist/core/log.js

@@ -1,27 +1,3 @@
-import { appendFileSync, existsSync, mkdirSync, renameSync, rmSync, statSync } from 'node:fs';
-import { dirname } from 'node:path';
-export const MAX_ROTATING_RECORD_BYTES = 65_536;
-const MAX_ACTIVE_BYTES = 5 * 1024 * 1024;
-/** Synchronously appends one complete NDJSON record, retaining active + .1 + .2. */
-export function appendRotatingRecord(path, recordWithoutLf) {
-    if (recordWithoutLf.includes('\n') || recordWithoutLf.includes('\r'))
-        return false;
-    const lineBytes = Buffer.byteLength(recordWithoutLf, 'utf8') + 1;
-    if (lineBytes > MAX_ROTATING_RECORD_BYTES)
-        return false;
-    try {
-        mkdirSync(dirname(path), { recursive: true });
-        const currentBytes = existsSync(path) ? statSync(path).size : 0;
-        if (currentBytes + lineBytes > MAX_ACTIVE_BYTES && currentBytes > 0) {
-            rmSync(`${path}.2`, { force: true });
-            if (existsSync(`${path}.1`))
-                renameSync(`${path}.1`, `${path}.2`);
-            renameSync(path, `${path}.1`);
-        }
-        appendFileSync(path, `${recordWithoutLf}\n`, 'utf8');
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
+var f=Object.defineProperty;var s=(e,n)=>f(e,"name",{value:n,configurable:!0});import{appendFileSync as u,existsSync as t,mkdirSync as y,renameSync as i,rmSync as m,statSync as o}from"node:fs";import{dirname as S}from"node:path";const l=65536,_=5*1024*1024;function T(e,n){if(n.includes(`
+`)||n.includes("\r"))return!1;const r=Buffer.byteLength(n,"utf8")+1;if(r>l)return!1;try{y(S(e),{recursive:!0});const c=t(e)?o(e).size:0;return c+r>_&&c>0&&(m(`${e}.2`,{force:!0}),t(`${e}.1`)&&i(`${e}.1`,`${e}.2`),i(e,`${e}.1`)),u(e,`${n}
+`,"utf8"),!0}catch{return!1}}s(T,"appendRotatingRecord");export{l as MAX_ROTATING_RECORD_BYTES,T as appendRotatingRecord};

package/dist/core/manifest-recovery.js

@@ -1,72 +1 @@
-// Dispatch with recovery from an out-of-date command description.
-//
-// Extracted from the cli entry so the whole behaviour — rethrow, refetch,
-// re-parse, exactly-once — can be driven by a test through `runCli` and a real
-// error off the wire, rather than only by launching the binary.
-import { resolveRoot } from '../build-root.js';
-import { runCli } from './command.js';
-import { forceRevalidateBundlePlugin } from './command-plugins/revalidate.js';
-import { handle } from './io.js';
-import { staleManifestPlugin } from './manifest-stale.js';
-/**
- * Run `argv` against `root`, and if the backend answers `manifest_stale`,
- * refetch that plugin's package and run the ORIGINAL argv again against a
- * freshly resolved tree — exactly once.
- *
- * Re-parsing the original argv, rather than re-running the leaf that failed, is
- * what makes a RENAMED verb recoverable: the old leaf no longer exists in the
- * refreshed tree, and only the dispatcher can answer that against the fresh
- * tree's own siblings.
- *
- * Never throws: every outcome is rendered through the dispatcher's own
- * `handle`, so a caller can mark the end of dispatch unconditionally.
- */
-export async function dispatchWithStaleRecovery(root, argv) {
-    try {
-        // The dispatcher renders every other failure itself; a `manifest_stale`
-        // error is the one it rethrows, because recovery needs this frame.
-        await runCli(root, argv);
-        return;
-    }
-    catch (error) {
-        if (!(await refetchStalePlugin(error))) {
-            // Nothing newer to run against: report the backend's own complaint
-            // exactly as the dispatcher would have.
-            handle(error);
-            return;
-        }
-        try {
-            // The refreshed tree, re-resolved: the package this invocation dispatches
-            // against is not the one it was built from. Replaying the argv is only
-            // safe because a server that sets the flag has promised it — the two
-            // preconditions are recorded on `ManifestStaleEnvelope` in
-            // `src/api/plugin-manifest-schema.ts`, and crtr cannot check either one.
-            await runCli(await resolveRoot(argv[2]), argv);
-        }
-        catch (retryError) {
-            // Exactly once. A second `manifest_stale` against a package just
-            // refetched is the server's answer, not another refresh cycle.
-            handle(retryError);
-        }
-    }
-}
-/**
- * A backend that answers `manifest_stale` is saying this client invoked from an
- * out-of-date description of its commands. Refetch that plugin's package and
- * report whether it actually changed. An unchanged package means the operation
- * is genuinely gone, so the server's own error, which already names what it
- * does serve, is the honest answer and stands.
- */
-async function refetchStalePlugin(error) {
-    const plugin = staleManifestPlugin(error);
-    if (plugin === undefined)
-        return false;
-    try {
-        return await forceRevalidateBundlePlugin(plugin);
-    }
-    catch {
-        // The refetch is the recovery. If it fails there is nothing newer to retry
-        // against, and the server's original complaint is what the caller needs.
-        return false;
-    }
-}
+var c=Object.defineProperty;var e=(t,r)=>c(t,"name",{value:r,configurable:!0});import{resolveRoot as f}from"../build-root.js";import{runCli as a}from"./command.js";import{forceRevalidateBundlePlugin as l}from"./command-plugins/revalidate.js";import{handle as n}from"./io.js";import{staleManifestPlugin as u}from"./manifest-stale.js";async function P(t,r){try{await a(t,r);return}catch(i){if(!await m(i)){n(i);return}try{await a(await f(r[2]),r)}catch(o){n(o)}}}e(P,"dispatchWithStaleRecovery");async function m(t){const r=u(t);if(r===void 0)return!1;try{return await l(r)}catch{return!1}}e(m,"refetchStalePlugin");export{P as dispatchWithStaleRecovery};

package/dist/core/manifest-stale.js

@@ -1,39 +1 @@
-// The one place in crtr that names the `manifest_stale` wire field.
-//
-// The field itself is declared in the published format subpath
-// (`src/api/plugin-manifest-schema.ts`), which is what a plugin backend compiles
-// against. This module binds crtr's readers and writer to that declaration, so
-// renaming the field there fails the build here rather than silently splitting
-// the two sides: a backend that keeps setting a field nobody reads, and a client
-// that never recovers.
-import { CrtrError } from './errors.js';
-/** Bound to the published declaration: `keyof` is the field's literal type, so
- *  a rename over there makes this assignment a type error. */
-const STALE_FIELD = 'manifest_stale';
-/** The plugin whose package produced the out-of-date description, carried
- *  alongside the flag so the recovery frame knows what to refetch. The backend
- *  does not send this — the transport that made the call names it. */
-const PLUGIN_FIELD = 'plugin';
-/** Did the backend's own error envelope claim staleness? Reads the parsed JSON
- *  body, before it becomes a `CrtrError`. */
-export function envelopeClaimsStale(envelope) {
-    return envelope[STALE_FIELD] === true;
-}
-/** The details a transport adds when it converts a stale envelope into the
- *  error the dispatcher rethrows. */
-export function staleErrorDetails(plugin) {
-    return { [STALE_FIELD]: true, [PLUGIN_FIELD]: plugin };
-}
-/** Is this the one error class the dispatcher rethrows instead of rendering? */
-export function isManifestStaleError(error) {
-    return error instanceof CrtrError && error.details?.[STALE_FIELD] === true;
-}
-/** The plugin to refetch, or `undefined` when this error is not a recoverable
- *  stale answer. A stale flag with no plugin name is not actionable: nothing
- *  identifies the package whose description went out of date. */
-export function staleManifestPlugin(error) {
-    if (!isManifestStaleError(error))
-        return undefined;
-    const plugin = error.details?.[PLUGIN_FIELD];
-    return typeof plugin === 'string' ? plugin : undefined;
-}
+var o=Object.defineProperty;var e=(t,n)=>o(t,"name",{value:n,configurable:!0});import{CrtrError as u}from"./errors.js";const r="manifest_stale",i="plugin";function l(t){return t[r]===!0}e(l,"envelopeClaimsStale");function p(t){return{[r]:!0,[i]:t}}e(p,"staleErrorDetails");function s(t){return t instanceof u&&t.details?.[r]===!0}e(s,"isManifestStaleError");function c(t){if(!s(t))return;const n=t.details?.[i];return typeof n=="string"?n:void 0}e(c,"staleManifestPlugin");export{l as envelopeClaimsStale,s as isManifestStaleError,p as staleErrorDetails,c as staleManifestPlugin};

package/dist/core/manifest.js

@@ -1,20 +1 @@
-import { join } from 'node:path';
-import { MARKETPLACE_MANIFEST_DIR, MARKETPLACE_MANIFEST_FILE, PLUGIN_MANIFEST_DIR, PLUGIN_MANIFEST_FILE, } from '../types.js';
-import { validatePluginMemoryExtensions } from './memory/extensions.js';
-import { readJsonIfExists } from './fs-utils.js';
-export function pluginManifestPath(pluginRoot) {
-    return join(pluginRoot, PLUGIN_MANIFEST_DIR, PLUGIN_MANIFEST_FILE);
-}
-export function marketplaceManifestPath(mktRoot) {
-    return join(mktRoot, MARKETPLACE_MANIFEST_DIR, MARKETPLACE_MANIFEST_FILE);
-}
-export function readPluginManifest(pluginRoot) {
-    return readJsonIfExists(pluginManifestPath(pluginRoot));
-}
-/** Validate an optional memory-extension declaration at package preflight. */
-export function validatePluginManifestMemoryExtensions(manifest) {
-    validatePluginMemoryExtensions(manifest);
-}
-export function readMarketplaceManifest(mktRoot) {
-    return readJsonIfExists(marketplaceManifestPath(mktRoot));
-}
+var o=Object.defineProperty;var n=(t,i)=>o(t,"name",{value:i,configurable:!0});import{join as r}from"node:path";import{MARKETPLACE_MANIFEST_DIR as a,MARKETPLACE_MANIFEST_FILE as f,PLUGIN_MANIFEST_DIR as M,PLUGIN_MANIFEST_FILE as u}from"../types.js";import{validatePluginMemoryExtensions as E}from"./memory/extensions.js";import{readJsonIfExists as e}from"./fs-utils.js";function p(t){return r(t,M,u)}n(p,"pluginManifestPath");function s(t){return r(t,a,f)}n(s,"marketplaceManifestPath");function A(t){return e(p(t))}n(A,"readPluginManifest");function _(t){E(t)}n(_,"validatePluginManifestMemoryExtensions");function c(t){return e(s(t))}n(c,"readMarketplaceManifest");export{s as marketplaceManifestPath,p as pluginManifestPath,c as readMarketplaceManifest,A as readPluginManifest,_ as validatePluginManifestMemoryExtensions};