@north-light/crouter 0.3.318 → 0.3.320

package/dist/core/command-plugins/endpoint.js

@@ -1,48 +1 @@
-import { validateEnvVarName } from '../env-name.js';
-function isLoopbackHostname(hostname) {
-    return hostname === 'localhost' || hostname === '127.0.0.1' || hostname === '[::1]' || hostname === '::1' || hostname === 'host.docker.internal';
-}
-export function validateEndpoint(endpoint) {
-    const errors = [];
-    if (typeof endpoint !== 'string')
-        errors.push('endpoint must be a string');
-    else {
-        try {
-            const url = new URL(endpoint);
-            if (url.protocol !== 'https:' && !(url.protocol === 'http:' && isLoopbackHostname(url.hostname)))
-                errors.push('endpoint must be an absolute https:// URL (http:// permitted for loopback hosts only; no credentials or fragment)');
-            else if (url.username || url.password || url.hash)
-                errors.push('endpoint must be an absolute https:// URL (http:// permitted for loopback hosts only; no credentials or fragment)');
-        }
-        catch {
-            errors.push('endpoint must be an absolute https:// URL (http:// permitted for loopback hosts only; no credentials or fragment)');
-        }
-    }
-    return { isValid: errors.length === 0, errors };
-}
-export function normalizeEndpoint(endpoint) {
-    try {
-        const url = new URL(endpoint);
-        const pathname = url.pathname.length > 1 && url.pathname.endsWith('/') ? url.pathname.slice(0, -1) : url.pathname;
-        return `${url.protocol}//${url.host}${pathname}${url.search}`;
-    }
-    catch {
-        return endpoint;
-    }
-}
-export function validateHttpPluginTransport(raw) {
-    const errors = [];
-    if (typeof raw !== 'object' || raw === null || Array.isArray(raw))
-        return { errors: ['transport must be an object'] };
-    const transport = raw;
-    const unknown = Object.keys(transport).filter((key) => !['kind', 'endpoint', 'authEnv'].includes(key));
-    if (unknown.length)
-        errors.push(`transport has unknown keys: ${unknown.join(', ')}`);
-    if (transport.kind !== 'http')
-        errors.push('transport.kind must be "http"');
-    const endpoint = validateEndpoint(transport.endpoint);
-    errors.push(...endpoint.errors);
-    if (transport.authEnv !== undefined)
-        errors.push(...validateEnvVarName(transport.authEnv).errors);
-    return errors.length ? { errors } : { transport: { kind: 'http', endpoint: normalizeEndpoint(transport.endpoint), ...(transport.authEnv !== undefined ? { authEnv: transport.authEnv } : {}) }, errors };
-}
+var a=Object.defineProperty;var e=(n,t)=>a(n,"name",{value:t,configurable:!0});import{validateEnvVarName as i}from"../env-name.js";function h(n){return n==="localhost"||n==="127.0.0.1"||n==="[::1]"||n==="::1"||n==="host.docker.internal"}e(h,"isLoopbackHostname");function u(n){const t=[];if(typeof n!="string")t.push("endpoint must be a string");else try{const o=new URL(n);(o.protocol!=="https:"&&!(o.protocol==="http:"&&h(o.hostname))||o.username||o.password||o.hash)&&t.push("endpoint must be an absolute https:// URL (http:// permitted for loopback hosts only; no credentials or fragment)")}catch{t.push("endpoint must be an absolute https:// URL (http:// permitted for loopback hosts only; no credentials or fragment)")}return{isValid:t.length===0,errors:t}}e(u,"validateEndpoint");function l(n){try{const t=new URL(n),o=t.pathname.length>1&&t.pathname.endsWith("/")?t.pathname.slice(0,-1):t.pathname;return`${t.protocol}//${t.host}${o}${t.search}`}catch{return n}}e(l,"normalizeEndpoint");function f(n){const t=[];if(typeof n!="object"||n===null||Array.isArray(n))return{errors:["transport must be an object"]};const o=n,r=Object.keys(o).filter(p=>!["kind","endpoint","authEnv"].includes(p));r.length&&t.push(`transport has unknown keys: ${r.join(", ")}`),o.kind!=="http"&&t.push('transport.kind must be "http"');const s=u(o.endpoint);return t.push(...s.errors),o.authEnv!==void 0&&t.push(...i(o.authEnv).errors),t.length?{errors:t}:{transport:{kind:"http",endpoint:l(o.endpoint),...o.authEnv!==void 0?{authEnv:o.authEnv}:{}},errors:t}}e(f,"validateHttpPluginTransport");export{l as normalizeEndpoint,u as validateEndpoint,f as validateHttpPluginTransport};

package/dist/core/command-plugins/extensions.js

@@ -1,166 +1 @@
-import { existsSync, realpathSync, readFileSync, readdirSync, statSync } from 'node:fs';
-import { dirname, isAbsolute, join, resolve, sep } from 'node:path';
-import { projectScopeRoots } from '../scope.js';
-import { validateCommandManifest } from '../command-manifests/manifest.js';
-import { executeExternalLeaf } from './transport/exec-invoke.js';
-import { isRecord } from '../../shared/predicates.js';
-function issue(fragmentPath, message, received, expected, next, nodePath) {
-    return {
-        code: 'command_extension_invalid',
-        message,
-        received,
-        expected,
-        next,
-        path: nodePath === undefined ? fragmentPath : `${fragmentPath}:${nodePath}`,
-    };
-}
-function regenerate(fragmentPath) {
-    return `Fix the repository CLI definition and regenerate ${fragmentPath}.`;
-}
-function safeExecutable(fragmentPath, root, executable) {
-    if (isAbsolute(executable)) {
-        return { issue: issue(fragmentPath, 'fragment transport executable must be project-relative', executable, 'a project-root-relative regular file', 'Fix transport.executable in the repository CLI definition and regenerate the fragment.', 'transport.executable') };
-    }
-    try {
-        const rootReal = realpathSync(root);
-        const resolved = realpathSync(resolve(root, executable));
-        if ((resolved !== rootReal && !resolved.startsWith(rootReal + sep)) || !statSync(resolved).isFile()) {
-            return { issue: issue(fragmentPath, 'fragment transport executable escapes the project root or is not a regular file', executable, 'a project-root-relative regular file', 'Fix transport.executable in the repository CLI definition and regenerate the fragment.', 'transport.executable') };
-        }
-        if ((statSync(resolved).mode & 0o111) === 0) {
-            return { issue: issue(fragmentPath, 'fragment transport executable lacks the POSIX exec bit', executable, 'a file with an executable permission bit', 'chmod +x the repository command executable, then regenerate the fragment.', 'transport.executable') };
-        }
-        return { executable: resolved };
-    }
-    catch {
-        return { issue: issue(fragmentPath, 'fragment transport executable escapes the project root or is not a regular file', executable, 'a project-root-relative regular file', 'Fix transport.executable in the repository CLI definition and regenerate the fragment.', 'transport.executable') };
-    }
-}
-function validateFragment(fragmentPath, projectRoot, branch, ownChildren) {
-    let raw;
-    try {
-        raw = JSON.parse(readFileSync(fragmentPath, 'utf8'));
-    }
-    catch {
-        return { issue: issue(fragmentPath, 'extension fragment is missing, unreadable, or not valid JSON', fragmentPath, 'a readable generated JSON fragment', `Regenerate ${fragmentPath}.`) };
-    }
-    if (!isRecord(raw)) {
-        return { issue: issue(fragmentPath, 'extension fragment must be an object', raw === null ? 'null' : Array.isArray(raw) ? 'array' : typeof raw, '{ schemaVersion, transport, mounts }', `Regenerate ${fragmentPath}.`) };
-    }
-    const unknown = Object.keys(raw).filter((key) => !['schemaVersion', 'transport', 'mounts'].includes(key));
-    if (unknown.length > 0) {
-        return { issue: issue(fragmentPath, 'extension fragment has unknown top-level keys', unknown.join(', '), 'only: schemaVersion, transport, mounts', `Regenerate ${fragmentPath}.`) };
-    }
-    const transport = raw['transport'];
-    if (!isRecord(transport) || Object.keys(transport).some((key) => !['kind', 'executable'].includes(key)) || transport['kind'] !== 'exec' || typeof transport['executable'] !== 'string' || transport['executable'].length === 0) {
-        return { issue: issue(fragmentPath, 'extension fragment transport must be { kind: "exec", executable: "project-relative path" }', JSON.stringify(transport), 'an exec transport with an executable', `Regenerate ${fragmentPath}.`, 'transport') };
-    }
-    const executableResult = safeExecutable(fragmentPath, projectRoot, transport['executable']);
-    if (executableResult.issue !== undefined)
-        return { issue: executableResult.issue };
-    const validation = validateCommandManifest(raw, {
-        transport: 'exec',
-        reservedCoreNames: new Set(),
-        extensionFragment: true,
-    });
-    if (validation.manifest === undefined) {
-        const source = validation.issues[0];
-        return {
-            issue: issue(fragmentPath, source.message, source.received, source.expected, regenerate(fragmentPath), source.path),
-        };
-    }
-    const conflict = validation.manifest.roots.find((root) => ownChildren.includes(root.name));
-    if (conflict !== undefined) {
-        return {
-            issue: issue(fragmentPath, `contributed command "${conflict.name}" conflicts with a child the extensible branch already owns`, conflict.name, 'a name not already owned by the plugin branch', `Rename "${conflict.name}" in the repository CLI tree, then regenerate ${fragmentPath}.`, conflict.name),
-        };
-    }
-    return { fragment: { roots: validation.manifest.roots, executable: executableResult.executable } };
-}
-function nearestFragment(branch, startDir) {
-    for (const scopeRoot of projectScopeRoots(startDir, null)) {
-        const projectRoot = dirname(scopeRoot);
-        const fragmentPath = join(scopeRoot, 'commands', `${branch}.json`);
-        if (existsSync(fragmentPath))
-            return { fragmentPath, projectRoot };
-    }
-    return undefined;
-}
-function markLeaves(node, leaves) {
-    if (node.kind === 'leaf') {
-        leaves.add(node);
-        return;
-    }
-    node.children.forEach((child) => markLeaves(child, leaves));
-}
-/** Attach the nearest repository-owned fragment to each marked plugin branch.
- * Discovery reads only; execution remains in the leaf adapter. */
-export function applyCommandExtensions(contributions, startDir = process.cwd()) {
-    const validations = [];
-    const attached = contributions.map((contribution) => {
-        if (contribution.node.extensible !== true)
-            return contribution;
-        const branch = contribution.node.name;
-        const located = nearestFragment(branch, startDir);
-        if (located === undefined)
-            return contribution;
-        const result = validateFragment(located.fragmentPath, located.projectRoot, branch, contribution.node.children.map((child) => child.name));
-        if (result.issue !== undefined) {
-            validations.push({ branch, fragmentPath: located.fragmentPath, projectRoot: located.projectRoot, issue: result.issue });
-            return {
-                ...contribution,
-                extensionIssue: { fragment: located.fragmentPath, message: result.issue.message },
-            };
-        }
-        const fragment = result.fragment;
-        validations.push({ branch, fragmentPath: located.fragmentPath, projectRoot: located.projectRoot });
-        const leaves = new WeakSet();
-        fragment.roots.forEach((root) => markLeaves(root, leaves));
-        return {
-            ...contribution,
-            node: { ...contribution.node, children: [...contribution.node.children, ...fragment.roots] },
-            adaptLeaf: (leaf, path) => {
-                if (!leaves.has(leaf))
-                    return contribution.adaptLeaf(leaf, path);
-                const commandPath = [...path];
-                return {
-                    outputKind: 'object',
-                    run: async (input) => executeExternalLeaf({
-                        extension: { branch, root: located.projectRoot },
-                        executable: fragment.executable,
-                        commandPath,
-                        output: leaf.output,
-                    }, input),
-                };
-            },
-        };
-    });
-    return { contributions: attached, validations };
-}
-/** Doctor's only directory scan: fragments with no matching effective marked branch are otherwise inert by design. */
-export function orphanCommandExtensionValidations(contributions, startDir = process.cwd()) {
-    const scopeRoot = projectScopeRoots(startDir, null)[0];
-    if (scopeRoot === undefined)
-        return [];
-    const commandsDir = join(scopeRoot, 'commands');
-    let names;
-    try {
-        names = readdirSync(commandsDir);
-    }
-    catch {
-        return [];
-    }
-    const extensible = new Set(contributions.filter((contribution) => contribution.node.extensible === true).map((contribution) => contribution.node.name));
-    return names.filter((name) => name.endsWith('.json')).flatMap((name) => {
-        const branch = name.slice(0, -'.json'.length);
-        if (extensible.has(branch))
-            return [];
-        const fragmentPath = join(commandsDir, name);
-        return [{
-                branch,
-                fragmentPath,
-                projectRoot: dirname(scopeRoot),
-                issue: issue(fragmentPath, `fragment names branch "${branch}" but no effective plugin branch is extensible`, branch, 'the name of an effective extensible plugin branch', `Mark the plugin branch extensible or rename/remove ${fragmentPath}.`),
-            }];
-    });
-}
+var S=Object.defineProperty;var l=(e,s)=>S(e,"name",{value:s,configurable:!0});import{existsSync as k,realpathSync as x,readFileSync as w,readdirSync as $,statSync as h}from"node:fs";import{dirname as b,isAbsolute as C,join as f,resolve as F,sep as L}from"node:path";import{projectScopeRoots as g}from"../scope.js";import{validateCommandManifest as I}from"../command-manifests/manifest.js";import{executeExternalLeaf as O}from"./transport/exec-invoke.js";import{isRecord as y}from"../../shared/predicates.js";function d(e,s,r,c,t,a){return{code:"command_extension_invalid",message:s,received:r,expected:c,next:t,path:a===void 0?e:`${e}:${a}`}}l(d,"issue");function E(e){return`Fix the repository CLI definition and regenerate ${e}.`}l(E,"regenerate");function N(e,s,r){if(C(r))return{issue:d(e,"fragment transport executable must be project-relative",r,"a project-root-relative regular file","Fix transport.executable in the repository CLI definition and regenerate the fragment.","transport.executable")};try{const c=x(s),t=x(F(s,r));return t!==c&&!t.startsWith(c+L)||!h(t).isFile()?{issue:d(e,"fragment transport executable escapes the project root or is not a regular file",r,"a project-root-relative regular file","Fix transport.executable in the repository CLI definition and regenerate the fragment.","transport.executable")}:(h(t).mode&73)===0?{issue:d(e,"fragment transport executable lacks the POSIX exec bit",r,"a file with an executable permission bit","chmod +x the repository command executable, then regenerate the fragment.","transport.executable")}:{executable:t}}catch{return{issue:d(e,"fragment transport executable escapes the project root or is not a regular file",r,"a project-root-relative regular file","Fix transport.executable in the repository CLI definition and regenerate the fragment.","transport.executable")}}}l(N,"safeExecutable");function J(e,s,r,c){let t;try{t=JSON.parse(w(e,"utf8"))}catch{return{issue:d(e,"extension fragment is missing, unreadable, or not valid JSON",e,"a readable generated JSON fragment",`Regenerate ${e}.`)}}if(!y(t))return{issue:d(e,"extension fragment must be an object",t===null?"null":Array.isArray(t)?"array":typeof t,"{ schemaVersion, transport, mounts }",`Regenerate ${e}.`)};const a=Object.keys(t).filter(o=>!["schemaVersion","transport","mounts"].includes(o));if(a.length>0)return{issue:d(e,"extension fragment has unknown top-level keys",a.join(", "),"only: schemaVersion, transport, mounts",`Regenerate ${e}.`)};const n=t.transport;if(!y(n)||Object.keys(n).some(o=>!["kind","executable"].includes(o))||n.kind!=="exec"||typeof n.executable!="string"||n.executable.length===0)return{issue:d(e,'extension fragment transport must be { kind: "exec", executable: "project-relative path" }',JSON.stringify(n),"an exec transport with an executable",`Regenerate ${e}.`,"transport")};const i=N(e,s,n.executable);if(i.issue!==void 0)return{issue:i.issue};const u=I(t,{transport:"exec",reservedCoreNames:new Set,extensionFragment:!0});if(u.manifest===void 0){const o=u.issues[0];return{issue:d(e,o.message,o.received,o.expected,E(e),o.path)}}const p=u.manifest.roots.find(o=>c.includes(o.name));return p!==void 0?{issue:d(e,`contributed command "${p.name}" conflicts with a child the extensible branch already owns`,p.name,"a name not already owned by the plugin branch",`Rename "${p.name}" in the repository CLI tree, then regenerate ${e}.`,p.name)}:{fragment:{roots:u.manifest.roots,executable:i.executable}}}l(J,"validateFragment");function V(e,s){for(const r of g(s,null)){const c=b(r),t=f(r,"commands",`${e}.json`);if(k(t))return{fragmentPath:t,projectRoot:c}}}l(V,"nearestFragment");function j(e,s){if(e.kind==="leaf"){s.add(e);return}e.children.forEach(r=>j(r,s))}l(j,"markLeaves");function q(e,s=process.cwd()){const r=[];return{contributions:e.map(t=>{if(t.node.extensible!==!0)return t;const a=t.node.name,n=V(a,s);if(n===void 0)return t;const i=J(n.fragmentPath,n.projectRoot,a,t.node.children.map(o=>o.name));if(i.issue!==void 0)return r.push({branch:a,fragmentPath:n.fragmentPath,projectRoot:n.projectRoot,issue:i.issue}),{...t,extensionIssue:{fragment:n.fragmentPath,message:i.issue.message}};const u=i.fragment;r.push({branch:a,fragmentPath:n.fragmentPath,projectRoot:n.projectRoot});const p=new WeakSet;return u.roots.forEach(o=>j(o,p)),{...t,node:{...t.node,children:[...t.node.children,...u.roots]},adaptLeaf:l((o,m)=>{if(!p.has(o))return t.adaptLeaf(o,m);const v=[...m];return{outputKind:"object",run:l(async R=>O({extension:{branch:a,root:n.projectRoot},executable:u.executable,commandPath:v,output:o.output},R),"run")}},"adaptLeaf")}}),validations:r}}l(q,"applyCommandExtensions");function z(e,s=process.cwd()){const r=g(s,null)[0];if(r===void 0)return[];const c=f(r,"commands");let t;try{t=$(c)}catch{return[]}const a=new Set(e.filter(n=>n.node.extensible===!0).map(n=>n.node.name));return t.filter(n=>n.endsWith(".json")).flatMap(n=>{const i=n.slice(0,-5);if(a.has(i))return[];const u=f(c,n);return[{branch:i,fragmentPath:u,projectRoot:b(r),issue:d(u,`fragment names branch "${i}" but no effective plugin branch is extensible`,i,"the name of an effective extensible plugin branch",`Mark the plugin branch extensible or rename/remove ${u}.`)}]})}l(z,"orphanCommandExtensionValidations");export{q as applyCommandExtensions,z as orphanCommandExtensionValidations};

package/dist/core/command-plugins/help-addenda.js

@@ -1,44 +1 @@
-// Plugin help addenda: a command plugin may append attributed product guidance
-// beneath a CORE command's help (`helpAddenda` in its command manifest).
-// Append-only, never replace — a plugin cannot alter substrate contract text.
-//
-// This module is the help-render lookup. It loads only on the help path
-// (dynamic import from runCli) and reads stored manifest bytes only (no
-// network). The caller supplies the SAME inputs the install/bundle gates pass
-// to `validateCommandManifest` — the reserved core names and the full core
-// command path set — so this lookup reproduces the gate's exact verdict: a
-// manifest whose `helpAddenda` was rejected at ingress (reported there as a
-// typed issue, e.g. `command_help_addendum_invalid`) contributes nothing at
-// render either. Ingress report and render can never disagree; nothing
-// disappears here that was not already loudly rejected at the gate.
-import { effectiveCommandPlugins, validatePluginCommands } from './discovery.js';
-/** Collect every enabled plugin's addendum targeting `commandPath` (the
- *  space-joined walked path, e.g. "cron add"), in plugin-name order. `gate`
- *  carries the strict-validation inputs the install/bundle gates use; the
- *  help renderer already holds both (build-root exports them).
- *
- *  `coreCommandPaths` arrives as a thunk because producing that set walks EVERY
- *  core subtree — the whole command tree loaded on a path that renders one
- *  leaf's help. So the claimant pass below runs the SAME validator without it:
- *  the core path set can only reject an addendum, never introduce one, so a
- *  commandPath no manifest claims tolerantly claims none under the gate either,
- *  and the expensive input is never forced. Claimants then re-validate strictly,
- *  reproducing the gate's exact verdict — a manifest the gate rejects renders
- *  nothing, including its valid keys. */
-export async function collectHelpAddenda(commandPath, gate, startDir, profileId) {
-    if (commandPath.length === 0)
-        return [];
-    const extensibleCoreBranches = await gate.extensibleCoreBranches();
-    const claimants = effectiveCommandPlugins(startDir, profileId).filter((plugin) => validatePluginCommands(plugin, gate.reservedCoreNames, undefined, extensibleCoreBranches).manifest?.helpAddenda?.[commandPath] !== undefined);
-    if (claimants.length === 0)
-        return [];
-    const coreCommandPaths = await gate.coreCommandPaths();
-    const out = [];
-    for (const plugin of claimants) {
-        const text = validatePluginCommands(plugin, gate.reservedCoreNames, coreCommandPaths, extensibleCoreBranches).manifest?.helpAddenda?.[commandPath];
-        if (text !== undefined)
-            out.push({ plugin: plugin.name, text });
-    }
-    out.sort((a, b) => a.plugin.localeCompare(b.plugin));
-    return out;
-}
+var u=Object.defineProperty;var a=(t,e)=>u(t,"name",{value:e,configurable:!0});import{effectiveCommandPlugins as m,validatePluginCommands as d}from"./discovery.js";async function h(t,e,l,c){if(t.length===0)return[];const i=await e.extensibleCoreBranches(),s=m(l,c).filter(n=>d(n,e.reservedCoreNames,void 0,i).manifest?.helpAddenda?.[t]!==void 0);if(s.length===0)return[];const f=await e.coreCommandPaths(),r=[];for(const n of s){const o=d(n,e.reservedCoreNames,f,i).manifest?.helpAddenda?.[t];o!==void 0&&r.push({plugin:n.name,text:o})}return r.sort((n,o)=>n.plugin.localeCompare(o.plugin)),r}a(h,"collectHelpAddenda");export{h as collectHelpAddenda};

package/dist/core/command-plugins/presence.js

@@ -1,17 +1 @@
-import { listInstalledPlugins, listInstalledPluginsInRoot } from '../resolver.js';
-import { projectScopeRoots } from '../scope.js';
-/** Whether an enabled command plugin survives nearest-scope name shadowing. */
-export function hasEffectiveCommandPlugins(startDir = process.cwd(), profileId) {
-    const seen = new Set();
-    const consider = (plugin) => {
-        if (seen.has(plugin.name))
-            return false;
-        seen.add(plugin.name);
-        return plugin.enabled && (plugin.manifest.commands !== undefined || plugin.manifest.transport !== undefined);
-    };
-    for (const root of projectScopeRoots(startDir, profileId)) {
-        if (listInstalledPluginsInRoot('project', root).some(consider))
-            return true;
-    }
-    return listInstalledPlugins('user').some(consider);
-}
+var a=Object.defineProperty;var n=(o,t)=>a(o,"name",{value:t,configurable:!0});import{listInstalledPlugins as f,listInstalledPluginsInRoot as m}from"../resolver.js";import{projectScopeRoots as d}from"../scope.js";function l(o=process.cwd(),t){const s=new Set,r=n(e=>s.has(e.name)?!1:(s.add(e.name),e.enabled&&(e.manifest.commands!==void 0||e.manifest.transport!==void 0)),"consider");for(const e of d(o,t))if(m("project",e).some(r))return!0;return f("user").some(r)}n(l,"hasEffectiveCommandPlugins");export{l as hasEffectiveCommandPlugins};

package/dist/core/command-plugins/revalidate.js

@@ -1,152 +1,2 @@
-// TTL-gated revalidation of installed bundle plugins.
-//
-// A bundle plugin's package is fetched once, at install. Without this pass a
-// long-lived machine keeps invoking the command tree it installed on day one,
-// so a leaf the server renamed fails from the client side with no way back
-// except a human running `crtr pkg plugin update`.
-//
-// The pass runs before the command tree is built, so a replacement it performs
-// is what this very invocation dispatches against. Being on that path, it is
-// also bound by what it may DRAG there: this module reaches only the leaf-level
-// scope, config, and installed-plugin readers — never `discovery.js`, which
-// pulls the manifest validators, the registry, and the composer onto every
-// single crtr invocation, nor `plugin-manage.js`, which pulls the whole package
-// command graph. The machinery that fetches and swaps a package is imported
-// only once a plugin is found due.
-import { readState } from '../config.js';
-import { listInstalledPluginsInRoot } from '../installed-plugins.js';
-import { scopeRoot } from '../scope.js';
-import { GLOBAL_TOKENS } from '../command.js';
-const DEFAULT_TTL_MS = 15 * 60 * 1000;
-/** Project first, so a project-scoped package shadows a user-scoped one of the
- *  same name exactly as the command tree resolves it. */
-const SCOPES = ['project', 'user'];
-/** How long a recorded check stands before the next invocation re-probes.
- *  `CRTR_PLUGIN_REVALIDATE_TTL_MS=0` disables the pass outright — which is how
- *  a test, or any process that must not reach the network, opts out. */
-function ttlMs() {
-    const raw = process.env['CRTR_PLUGIN_REVALIDATE_TTL_MS'];
-    if (raw === undefined || raw.trim() === '')
-        return DEFAULT_TTL_MS;
-    const parsed = Number(raw);
-    if (!Number.isFinite(parsed) || parsed < 0)
-        return DEFAULT_TTL_MS;
-    return parsed;
-}
-/** A check is fresh for `ttl` after it happened. A `checked_at` in the FUTURE
- *  did not happen: a clock that jumped back, or a file copied from another
- *  machine, must not be able to suppress the pass until the clock catches up. */
-function isFresh(checkedAt, ttl, now) {
-    if (checkedAt === undefined)
-        return false;
-    const at = Date.parse(checkedAt);
-    if (Number.isNaN(at))
-        return false;
-    const age = now - at;
-    return age >= 0 && age < ttl;
-}
-/** A command that manages packages does its own fetching, with its own reporting
- *  and its own exit codes. Revalidating underneath it would race that work and
- *  make the leaf's result describe a package it did not install. `crtr --json
- *  pkg …` is that same command: the global tokens the dispatcher strips are not
- *  part of the command path here either. */
-function managesPackages(argv) {
-    return argv.slice(2).find((token) => !GLOBAL_TOKENS.has(token)) === 'pkg';
-}
-/** Every bundle plugin whose last check has aged out, resolved from the same
- *  scope root whose state ledger records the check — so the plugin read and the
- *  `checked_at` write can never describe different roots. */
-function duePlugins(ttl, now) {
-    const due = [];
-    const claimed = new Set();
-    for (const scope of SCOPES) {
-        const root = scopeRoot(scope);
-        if (root === null)
-            continue;
-        const state = readState(scope);
-        for (const plugin of listInstalledPluginsInRoot(scope, root)) {
-            if (claimed.has(plugin.name))
-                continue;
-            claimed.add(plugin.name);
-            const bundle = plugin.manifest.bundle;
-            if (!plugin.enabled || bundle === undefined)
-                continue;
-            if (isFresh(state.plugins[plugin.name]?.checked_at, ttl, now))
-                continue;
-            due.push({ name: plugin.name, scope, bundle, enabled: plugin.enabled });
-        }
-    }
-    return due;
-}
-/**
- * Bring every installed bundle plugin whose last check has aged out back in
- * step with its endpoint. Never throws: a plugin that cannot be revalidated
- * keeps the package already unpacked on disk, which is a complete and valid
- * command tree, and the failure is reported on stderr rather than replacing the
- * caller's command with an error about a background check.
- */
-export async function revalidateBundlePlugins(argv) {
-    const ttl = ttlMs();
-    if (ttl === 0 || managesPackages(argv))
-        return;
-    let due;
-    try {
-        due = duePlugins(ttl, Date.now());
-    }
-    catch {
-        // Enumeration reads config, state, and every installed plugin.json. A scope
-        // this process cannot read is a scope it also cannot revalidate, and the
-        // command it was invoked for may not need plugins at all.
-        return;
-    }
-    if (due.length === 0)
-        return;
-    const { revalidateBundlePlugin } = await import('../../commands/pkg/plugin-manage.js');
-    for (const plugin of due) {
-        try {
-            await revalidateBundlePlugin(plugin.name, plugin.bundle, plugin.scope, {
-                enable: plugin.enabled,
-                conditional: true,
-                timeoutMs: 2_000,
-            });
-        }
-        catch (error) {
-            const detail = error instanceof Error ? error.message : String(error);
-            process.stderr.write(`crtr: plugin "${plugin.name}" could not be revalidated (${detail}); using the installed package.\n`);
-        }
-    }
-}
-/**
- * Force one plugin back in step with its endpoint, ignoring both the TTL and
- * the stored validator. Recovery from a server that answered `manifest_stale`:
- * the description the caller invoked from is out of date, so the check that
- * would normally be skipped is exactly the one that has to run.
- *
- * Returns whether the package on disk actually changed, so a caller can tell a
- * recoverable staleness from an operation that is genuinely gone.
- */
-export async function forceRevalidateBundlePlugin(name) {
-    let plugin;
-    for (const scope of SCOPES) {
-        const root = scopeRoot(scope);
-        if (root === null)
-            continue;
-        plugin = listInstalledPluginsInRoot(scope, root).find((candidate) => candidate.name === name);
-        if (plugin !== undefined)
-            break;
-    }
-    const bundle = plugin?.manifest.bundle;
-    if (plugin === undefined || bundle === undefined)
-        return false;
-    const { revalidateBundlePlugin } = await import('../../commands/pkg/plugin-manage.js');
-    // An unconditional refetch either swaps the package or reports that the bytes
-    // the server served are byte-identical to the ones already unpacked. Both
-    // answers are the swap's own, so `undefined` here means "nothing changed" —
-    // the operation the caller invoked is genuinely gone, and the server's error
-    // stands.
-    const replaced = await revalidateBundlePlugin(name, bundle, plugin.scope, {
-        enable: plugin.enabled,
-        conditional: false,
-    });
-    return replaced !== undefined;
-}
+var m=Object.defineProperty;var s=(n,e)=>m(n,"name",{value:e,configurable:!0});import{readState as g}from"../config.js";import{listInstalledPluginsInRoot as l}from"../installed-plugins.js";import{scopeRoot as d}from"../scope.js";import{GLOBAL_TOKENS as b}from"../command.js";const f=900*1e3,p=["project","user"];function P(){const n=process.env.CRTR_PLUGIN_REVALIDATE_TTL_MS;if(n===void 0||n.trim()==="")return f;const e=Number(n);return!Number.isFinite(e)||e<0?f:e}s(P,"ttlMs");function _(n,e,i){if(n===void 0)return!1;const o=Date.parse(n);if(Number.isNaN(o))return!1;const t=i-o;return t>=0&&t<e}s(_,"isFresh");function h(n){return n.slice(2).find(e=>!b.has(e))==="pkg"}s(h,"managesPackages");function w(n,e){const i=[],o=new Set;for(const t of p){const r=d(t);if(r===null)continue;const u=g(t);for(const a of l(t,r)){if(o.has(a.name))continue;o.add(a.name);const c=a.manifest.bundle;!a.enabled||c===void 0||_(u.plugins[a.name]?.checked_at,n,e)||i.push({name:a.name,scope:t,bundle:c,enabled:a.enabled})}}return i}s(w,"duePlugins");async function E(n){const e=P();if(e===0||h(n))return;let i;try{i=w(e,Date.now())}catch{return}if(i.length===0)return;const{revalidateBundlePlugin:o}=await import("../../commands/pkg/plugin-manage.js");for(const t of i)try{await o(t.name,t.bundle,t.scope,{enable:t.enabled,conditional:!0,timeoutMs:2e3})}catch(r){const u=r instanceof Error?r.message:String(r);process.stderr.write(`crtr: plugin "${t.name}" could not be revalidated (${u}); using the installed package.
+`)}}s(E,"revalidateBundlePlugins");async function R(n){let e;for(const r of p){const u=d(r);if(u!==null&&(e=l(r,u).find(a=>a.name===n),e!==void 0))break}const i=e?.manifest.bundle;if(e===void 0||i===void 0)return!1;const{revalidateBundlePlugin:o}=await import("../../commands/pkg/plugin-manage.js");return await o(n,i,e.scope,{enable:e.enabled,conditional:!1})!==void 0}s(R,"forceRevalidateBundlePlugin");export{R as forceRevalidateBundlePlugin,E as revalidateBundlePlugins};