@north-light/crouter 0.3.318 → 0.3.320

package/dist/core/command-hooks/artifact.js

@@ -1,145 +1 @@
-import { readFileSync, realpathSync, statSync } from 'node:fs';
-import { isAbsolute, resolve, sep } from 'node:path';
-import { validateHookManifest } from './schema.js';
-function lifecycleCandidates(raw) {
-    if (typeof raw !== 'object' || raw === null || Array.isArray(raw))
-        return [];
-    const lifecycle = raw['lifecycle'];
-    if (!Array.isArray(lifecycle))
-        return [];
-    return lifecycle.flatMap((value, index) => {
-        if (typeof value !== 'object' || value === null || Array.isArray(value))
-            return [];
-        const declaration = value;
-        return typeof declaration['event'] === 'string'
-            ? [{ event: declaration['event'], op: typeof declaration['op'] === 'string' ? declaration['op'] : '<invalid>', index }]
-            : [];
-    });
-}
-function safeFilePath(root, pointer) {
-    if (isAbsolute(pointer))
-        return null;
-    try {
-        const rootReal = realpathSync(root);
-        const path = realpathSync(resolve(root, pointer));
-        return (path === rootReal || path.startsWith(rootReal + sep)) && statSync(path).isFile() ? path : null;
-    }
-    catch {
-        return null;
-    }
-}
-/** Statically validates the local hook artifact a source plugin ships. */
-export function validatePluginHookArtifact(root, manifest) {
-    const hooks = manifest.hooks;
-    const executable = manifest.hookExecutable;
-    const issues = [];
-    const hasHooks = hooks !== undefined;
-    const hasExecutable = executable !== undefined;
-    if (hasHooks !== hasExecutable) {
-        issues.push({
-            code: 'hook_manifest_invalid',
-            path: hasHooks ? 'hookExecutable' : 'hooks',
-            message: 'hooks and hookExecutable must be declared together',
-            received: hasHooks ? 'hooks without hookExecutable' : 'hookExecutable without hooks',
-            expected: 'both hooks and hookExecutable',
-            next: hasHooks ? 'Add plugin.json.hookExecutable or remove hooks.' : 'Add plugin.json.hooks or remove hookExecutable.',
-        });
-        return { lifecycleCandidates: [], issues };
-    }
-    if (!hasHooks)
-        return { lifecycleCandidates: [], issues };
-    if (typeof hooks !== 'string' || hooks.length === 0) {
-        issues.push({
-            code: 'hook_manifest_invalid',
-            path: 'hooks',
-            message: 'hooks must be a non-empty plugin-root-relative path',
-            received: typeof hooks === 'string' ? '(empty)' : Array.isArray(hooks) ? 'array' : typeof hooks,
-            expected: 'a non-empty relative path to hooks.json',
-            next: 'Fix plugin.json.hooks.',
-        });
-    }
-    if (typeof executable !== 'string' || executable.length === 0) {
-        issues.push({
-            code: 'hook_manifest_invalid',
-            path: 'hookExecutable',
-            message: 'hookExecutable must be a non-empty plugin-root-relative path',
-            received: typeof executable === 'string' ? '(empty)' : Array.isArray(executable) ? 'array' : typeof executable,
-            expected: 'a non-empty relative path to an executable file',
-            next: 'Fix plugin.json.hookExecutable.',
-        });
-    }
-    if (issues.length > 0)
-        return { lifecycleCandidates: [], issues };
-    const hooksPointer = hooks;
-    const executablePointer = executable;
-    const manifestPath = safeFilePath(root, hooksPointer);
-    if (manifestPath === null) {
-        issues.push({
-            code: 'hook_path_unsafe',
-            path: 'hooks',
-            message: 'hooks pointer escapes the plugin root or is not a regular file',
-            received: hooksPointer,
-            expected: 'a relative path to a regular file inside the plugin root',
-            next: 'Fix plugin.json.hooks.',
-        });
-    }
-    const executablePath = safeFilePath(root, executablePointer);
-    if (executablePath === null) {
-        issues.push({
-            code: 'hook_path_unsafe',
-            path: 'hookExecutable',
-            message: 'hookExecutable escapes the plugin root or is not a regular file',
-            received: executablePointer,
-            expected: 'a relative path to a regular file inside the plugin root',
-            next: 'Fix plugin.json.hookExecutable.',
-        });
-    }
-    if (executablePath !== null && (statSync(executablePath).mode & 0o111) === 0) {
-        issues.push({
-            code: 'hook_not_executable',
-            path: 'hookExecutable',
-            message: 'hookExecutable lacks the POSIX exec bit',
-            received: executablePointer,
-            expected: 'a file with an executable permission bit',
-            next: 'chmod +x the hook executable, then update the plugin.',
-        });
-    }
-    if (manifestPath === null)
-        return { lifecycleCandidates: [], ...(executablePath === null ? {} : { executablePath }), issues };
-    let text;
-    try {
-        text = readFileSync(manifestPath, 'utf8');
-    }
-    catch {
-        issues.push({
-            code: 'hook_manifest_unreadable',
-            message: 'hooks.json is missing or unreadable',
-            received: manifestPath,
-            expected: 'a readable JSON file',
-            next: 'Reinstall or update the plugin.',
-        });
-        return { manifestPath, lifecycleCandidates: [], ...(executablePath === null ? {} : { executablePath }), issues };
-    }
-    let raw;
-    try {
-        raw = JSON.parse(text);
-    }
-    catch {
-        issues.push({
-            code: 'hook_manifest_invalid',
-            message: 'hooks.json is not valid JSON',
-            received: manifestPath,
-            expected: 'a JSON object',
-            next: 'Regenerate hooks.json.',
-        });
-        return { manifestPath, lifecycleCandidates: [], ...(executablePath === null ? {} : { executablePath }), issues };
-    }
-    const validation = validateHookManifest(raw);
-    return {
-        manifestPath,
-        lifecycleCandidates: lifecycleCandidates(raw),
-        ...(executablePath === null ? {} : { executablePath }),
-        ...(validation.manifest === undefined ? {} : { manifest: validation.manifest }),
-        issues: [...issues, ...validation.issues],
-    };
-}
+var y=Object.defineProperty;var r=(a,i)=>y(a,"name",{value:i,configurable:!0});import{readFileSync as g,realpathSync as f,statSync as k}from"node:fs";import{isAbsolute as b,resolve as m,sep as v}from"node:path";import{validateHookManifest as E}from"./schema.js";function _(a){if(typeof a!="object"||a===null||Array.isArray(a))return[];const i=a.lifecycle;return Array.isArray(i)?i.flatMap((t,o)=>{if(typeof t!="object"||t===null||Array.isArray(t))return[];const e=t;return typeof e.event=="string"?[{event:e.event,op:typeof e.op=="string"?e.op:"<invalid>",index:o}]:[]}):[]}r(_,"lifecycleCandidates");function x(a,i){if(b(i))return null;try{const t=f(a),o=f(m(a,i));return(o===t||o.startsWith(t+v))&&k(o).isFile()?o:null}catch{return null}}r(x,"safeFilePath");function P(a,i){const t=i.hooks,o=i.hookExecutable,e=[],l=t!==void 0;if(l!==(o!==void 0))return e.push({code:"hook_manifest_invalid",path:l?"hookExecutable":"hooks",message:"hooks and hookExecutable must be declared together",received:l?"hooks without hookExecutable":"hookExecutable without hooks",expected:"both hooks and hookExecutable",next:l?"Add plugin.json.hookExecutable or remove hooks.":"Add plugin.json.hooks or remove hookExecutable."}),{lifecycleCandidates:[],issues:e};if(!l)return{lifecycleCandidates:[],issues:e};if((typeof t!="string"||t.length===0)&&e.push({code:"hook_manifest_invalid",path:"hooks",message:"hooks must be a non-empty plugin-root-relative path",received:typeof t=="string"?"(empty)":Array.isArray(t)?"array":typeof t,expected:"a non-empty relative path to hooks.json",next:"Fix plugin.json.hooks."}),(typeof o!="string"||o.length===0)&&e.push({code:"hook_manifest_invalid",path:"hookExecutable",message:"hookExecutable must be a non-empty plugin-root-relative path",received:typeof o=="string"?"(empty)":Array.isArray(o)?"array":typeof o,expected:"a non-empty relative path to an executable file",next:"Fix plugin.json.hookExecutable."}),e.length>0)return{lifecycleCandidates:[],issues:e};const p=t,c=o,s=x(a,p);s===null&&e.push({code:"hook_path_unsafe",path:"hooks",message:"hooks pointer escapes the plugin root or is not a regular file",received:p,expected:"a relative path to a regular file inside the plugin root",next:"Fix plugin.json.hooks."});const n=x(a,c);if(n===null&&e.push({code:"hook_path_unsafe",path:"hookExecutable",message:"hookExecutable escapes the plugin root or is not a regular file",received:c,expected:"a relative path to a regular file inside the plugin root",next:"Fix plugin.json.hookExecutable."}),n!==null&&(k(n).mode&73)===0&&e.push({code:"hook_not_executable",path:"hookExecutable",message:"hookExecutable lacks the POSIX exec bit",received:c,expected:"a file with an executable permission bit",next:"chmod +x the hook executable, then update the plugin."}),s===null)return{lifecycleCandidates:[],...n===null?{}:{executablePath:n},issues:e};let d;try{d=g(s,"utf8")}catch{return e.push({code:"hook_manifest_unreadable",message:"hooks.json is missing or unreadable",received:s,expected:"a readable JSON file",next:"Reinstall or update the plugin."}),{manifestPath:s,lifecycleCandidates:[],...n===null?{}:{executablePath:n},issues:e}}let u;try{u=JSON.parse(d)}catch{return e.push({code:"hook_manifest_invalid",message:"hooks.json is not valid JSON",received:s,expected:"a JSON object",next:"Regenerate hooks.json."}),{manifestPath:s,lifecycleCandidates:[],...n===null?{}:{executablePath:n},issues:e}}const h=E(u);return{manifestPath:s,lifecycleCandidates:_(u),...n===null?{}:{executablePath:n},...h.manifest===void 0?{}:{manifest:h.manifest},issues:[...e,...h.issues]}}r(P,"validatePluginHookArtifact");export{P as validatePluginHookArtifact};

package/dist/core/command-hooks/catalog.js

@@ -1,38 +1 @@
-const NON_RETURNING_OBJECT_LEAVES = new Set([
-    'pkg browse',
-    'sys settings',
-    'sys setup',
-    'canvas browse',
-    'surface inspect',
-]);
-function excluded(path) {
-    return path === 'sys doctor'
-        || path === 'pkg plugin'
-        || path.startsWith('pkg plugin ')
-        || NON_RETURNING_OBJECT_LEAVES.has(path);
-}
-/** Projects every composed core subtree to leaves whose objects flow through central rendering. */
-export function createCoreHookCatalog(subtrees) {
-    const targets = [];
-    const visit = (node, segments) => {
-        const path = segments.join(' ');
-        if (node.kind === 'leaf') {
-            if (node.help.outputKind === 'object' && node.hookEligible !== false && !excluded(path)) {
-                targets.push({ path, segments: Object.freeze([...segments]), leaf: node });
-            }
-            return;
-        }
-        if (node.passthrough !== undefined || excluded(path))
-            return;
-        for (const child of node.children)
-            visit(child, [...segments, child.name]);
-    };
-    for (const subtree of subtrees)
-        visit(subtree, [subtree.name]);
-    const byPath = new Map(targets.map((target) => [target.path, target]));
-    return Object.freeze({
-        targets: Object.freeze(targets),
-        byPath,
-        has: (path) => byPath.has(path),
-    });
-}
+var u=Object.defineProperty;var r=(t,s)=>u(t,"name",{value:s,configurable:!0});const p=new Set(["pkg browse","sys settings","sys setup","canvas browse","surface inspect"]);function f(t){return t==="sys doctor"||t==="pkg plugin"||t.startsWith("pkg plugin ")||p.has(t)}r(f,"excluded");function h(t){const s=[],c=r((e,n)=>{const o=n.join(" ");if(e.kind==="leaf"){e.help.outputKind==="object"&&e.hookEligible!==!1&&!f(o)&&s.push({path:o,segments:Object.freeze([...n]),leaf:e});return}if(!(e.passthrough!==void 0||f(o)))for(const a of e.children)c(a,[...n,a.name])},"visit");for(const e of t)c(e,[e.name]);const i=new Map(s.map(e=>[e.path,e]));return Object.freeze({targets:Object.freeze(s),byPath:i,has:r(e=>i.has(e),"has")})}r(h,"createCoreHookCatalog");export{h as createCoreHookCatalog};

package/dist/core/command-hooks/compose.js

@@ -1,99 +1 @@
-import { ExitCode } from '../../types.js';
-import { CrtrError } from '../errors.js';
-import { operationIdContext } from '../events/operation-id.js';
-import { createCoreHookCatalog } from './catalog.js';
-/** Wrap every hook-eligible core leaf so its run is the before → primary →
- *  after pipeline. Nothing else about the leaf changes: path, params, frozen
- *  help, renderer, and output declaration are carried through untouched, and
- *  ineligible leaves (JSONL, UI/void, `pkg plugin`, `sys doctor`, passthrough)
- *  keep their original run function so recovery dispatch never depends on hook
- *  discovery.
- *
- *  Eligibility is per-path, so projecting the passed subtrees answers it for
- *  those subtrees exactly as the complete catalog would; the complete catalog
- *  is what the loaded registry validates hook targets against. */
-export function composeCoreHooks(subtrees, loadRegistry) {
-    const eligible = createCoreHookCatalog(subtrees);
-    const visit = (node, segments) => {
-        if (node.kind === 'leaf') {
-            const path = segments.join(' ');
-            if (!eligible.has(path))
-                return node;
-            return Object.freeze({
-                ...node,
-                effectiveHelp: projectedHelp(node, path, loadRegistry),
-                run: hookedRun(node, segments, loadRegistry),
-            });
-        }
-        return { ...node, children: node.children.map((child) => visit(child, [...segments, child.name])) };
-    };
-    return subtrees.map((subtree) => visit(subtree, [subtree.name]));
-}
-function projectedHelp(leaf, path, loadRegistry) {
-    return async () => {
-        const { projectEffectiveLeafHelp } = await import('./help.js');
-        try {
-            const registry = await loadRegistry();
-            // Invalid configuration fails closed on dispatch, but help remains the
-            // bounded static core contract so recovery is never stranded.
-            return projectEffectiveLeafHelp(leaf.help, registry.valid ? registry.plans.get(path) : undefined);
-        }
-        catch {
-            return projectEffectiveLeafHelp(leaf.help);
-        }
-    };
-}
-function hookedRun(leaf, segments, loadRegistry) {
-    const core = leaf.run;
-    const path = segments.join(' ');
-    return async (input, context) => {
-        const registry = await loadRegistry();
-        if (!registry.valid)
-            throw registryError(path, registry.issues);
-        const plan = registry.plans.get(path);
-        if (plan === undefined)
-            return core(input, context);
-        // The one fresh operation identity runCli already entered surrounds this
-        // whole pipeline; hooks and the core primary share that ambient ID.
-        const operationId = operationIdContext.current();
-        if (operationId === undefined)
-            throw new CrtrError('internal', `\`${path}\` ran outside a crouter operation identity, so its plugin hooks cannot be dispatched.`, ExitCode.GENERAL, { command: [...segments] });
-        const { invokeExecHook } = await import('./transport/exec-invoke.js');
-        const spec = (hook) => ({
-            plugin: hook.plugin.name,
-            executable: hook.executable,
-            op: hook.op,
-            phase: hook.phase,
-            commandPath: segments,
-            ...(hook.phase === 'replace' ? { output: leaf.help.output } : {}),
-        });
-        const providedParams = [...(context?.providedParams ?? [])];
-        for (const hook of plan.before)
-            await invokeExecHook(spec(hook), { operationId, input, providedParams });
-        const replacement = plan.replacements[0];
-        const result = replacement === undefined
-            ? await core(input, context)
-            : await invokeExecHook(spec(replacement), { operationId, input, providedParams });
-        // `after` is reverse discovery order, preserving middleware nesting.
-        for (const hook of plan.after)
-            await invokeExecHook(spec(hook), { operationId, input, providedParams, ...(result === undefined ? {} : { result }) });
-        return result;
-    };
-}
-/** Fail closed on an invalid manifest, stale target, or replacement collision:
- *  silently dropping a declared hook would run the command without behavior the
- *  caller expects. Every issue is spelled out in the message, because the
- *  central error payload carries only code/message/received/field/next — an
- *  issue list parked in `details` would never reach the caller. */
-function registryError(path, issues) {
-    const first = issues[0];
-    const detail = issues
-        .map((issue) => `${issue.plugin} (${issue.scope}) ${issue.path ?? 'hooks'}: ${issue.message} — received ${issue.received}, expected ${issue.expected}`)
-        .join('; ');
-    const plugins = [...new Set(issues.map((issue) => issue.plugin))];
-    return new CrtrError(first.code, `\`${path}\` cannot run: ${String(issues.length)} unusable hook declaration${issues.length === 1 ? '' : 's'} — ${detail}.`, ExitCode.GENERAL, {
-        received: first.received,
-        ...(first.path === undefined ? {} : { field: first.path }),
-        next: `${first.next} ${plugins.map((plugin) => `\`crtr pkg plugin show ${plugin}\``).join(' and ')} or \`crtr sys doctor\` reports the same issues; disabling the plugin also clears them.`,
-    });
-}
+var v=Object.defineProperty;var p=(n,r)=>v(n,"name",{value:r,configurable:!0});import{ExitCode as w}from"../../types.js";import{CrtrError as $}from"../errors.js";import{operationIdContext as E}from"../events/operation-id.js";import{createCoreHookCatalog as k}from"./catalog.js";function A(n,r){const o=k(n),a=p((t,e)=>{if(t.kind==="leaf"){const i=e.join(" ");return o.has(i)?Object.freeze({...t,effectiveHelp:x(t,i,r),run:j(t,e,r)}):t}return{...t,children:t.children.map(i=>a(i,[...e,i.name]))}},"visit");return n.map(t=>a(t,[t.name]))}p(A,"composeCoreHooks");function x(n,r,o){return async()=>{const{projectEffectiveLeafHelp:a}=await import("./help.js");try{const t=await o();return a(n.help,t.valid?t.plans.get(r):void 0)}catch{return a(n.help)}}}p(x,"projectedHelp");function j(n,r,o){const a=n.run,t=r.join(" ");return async(e,i)=>{const f=await o();if(!f.valid)throw y(t,f.issues);const d=f.plans.get(t);if(d===void 0)return a(e,i);const l=E.current();if(l===void 0)throw new $("internal",`\`${t}\` ran outside a crouter operation identity, so its plugin hooks cannot be dispatched.`,w.GENERAL,{command:[...r]});const{invokeExecHook:s}=await import("./transport/exec-invoke.js"),u=p(c=>({plugin:c.plugin.name,executable:c.executable,op:c.op,phase:c.phase,commandPath:r,...c.phase==="replace"?{output:n.help.output}:{}}),"spec"),h=[...i?.providedParams??[]];for(const c of d.before)await s(u(c),{operationId:l,input:e,providedParams:h});const g=d.replacements[0],m=g===void 0?await a(e,i):await s(u(g),{operationId:l,input:e,providedParams:h});for(const c of d.after)await s(u(c),{operationId:l,input:e,providedParams:h,...m===void 0?{}:{result:m}});return m}}p(j,"hookedRun");function y(n,r){const o=r[0],a=r.map(e=>`${e.plugin} (${e.scope}) ${e.path??"hooks"}: ${e.message} \u2014 received ${e.received}, expected ${e.expected}`).join("; "),t=[...new Set(r.map(e=>e.plugin))];return new $(o.code,`\`${n}\` cannot run: ${String(r.length)} unusable hook declaration${r.length===1?"":"s"} \u2014 ${a}.`,w.GENERAL,{received:o.received,...o.path===void 0?{}:{field:o.path},next:`${o.next} ${t.map(e=>`\`crtr pkg plugin show ${e}\``).join(" and ")} or \`crtr sys doctor\` reports the same issues; disabling the plugin also clears them.`})}p(y,"registryError");export{A as composeCoreHooks};

package/dist/core/command-hooks/discovery.js

@@ -1,228 +1 @@
-import { listInstalledPluginsInRoot } from '../resolver.js';
-import { projectScopeRoots, userScopeRoot } from '../scope.js';
-import { validatePluginHookArtifact } from './artifact.js';
-function hasHookDeclaration(plugin) {
-    return plugin.manifest.hooks !== undefined || plugin.manifest.hookExecutable !== undefined;
-}
-function orderedPluginsInScopes(scopes) {
-    const seen = new Set();
-    const result = [];
-    for (const scope of scopes) {
-        const plugins = listInstalledPluginsInRoot(scope.scope, scope.root).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
-        for (const plugin of plugins) {
-            if (seen.has(plugin.name))
-                continue;
-            seen.add(plugin.name);
-            if (plugin.enabled && hasHookDeclaration(plugin))
-                result.push(plugin);
-        }
-    }
-    return result;
-}
-/** Project scopes nearest-outward, followed by the user scope. */
-export function hookDiscoveryScopes(startDir = process.cwd(), profileId) {
-    return [
-        ...projectScopeRoots(startDir, profileId).map((root) => ({ scope: 'project', root })),
-        { scope: 'user', root: userScopeRoot() },
-    ];
-}
-/** Effective enabled hook plugins, with disabled nearest copies still shadowing outer copies. */
-export function effectiveHookPlugins(startDir = process.cwd(), profileId) {
-    return orderedPluginsInScopes(hookDiscoveryScopes(startDir, profileId));
-}
-function effectiveHookPluginsWithCandidates(candidates, startDir = process.cwd(), profileId) {
-    const seen = new Set();
-    const result = [];
-    for (const scope of hookDiscoveryScopes(startDir, profileId)) {
-        const replacements = candidates.filter((candidate) => candidate.plugin.scope === scope.scope && candidate.scopeRoot === scope.root);
-        const replacedNames = new Set(replacements.map((candidate) => candidate.plugin.name));
-        const plugins = [
-            ...listInstalledPluginsInRoot(scope.scope, scope.root).filter((plugin) => !replacedNames.has(plugin.name)),
-            ...replacements.map((candidate) => candidate.plugin),
-        ];
-        plugins.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
-        for (const plugin of plugins) {
-            if (seen.has(plugin.name))
-                continue;
-            seen.add(plugin.name);
-            if (plugin.enabled && hasHookDeclaration(plugin))
-                result.push(plugin);
-        }
-    }
-    return result;
-}
-function issue(plugin, value) {
-    return { ...value, plugin: plugin.name, scope: plugin.scope };
-}
-function artifactIssues(plugin, issues) {
-    return issues.map((value) => issue(plugin, value));
-}
-function targetIssues(plugin, hooks, catalog) {
-    const issues = [];
-    hooks.forEach((hook, index) => {
-        if (catalog.has(hook.target))
-            return;
-        issues.push(issue(plugin, {
-            code: 'command_hook_target_invalid',
-            path: `hooks[${index}].target`,
-            message: `hook target "${hook.target}" is not an eligible core returned-object leaf`,
-            received: hook.target,
-            expected: 'an exact eligible core leaf path',
-            next: 'Choose a current returned-object core leaf; pkg plugin, sys doctor, JSONL, passthrough, and UI/void surfaces are unavailable.',
-        }));
-    });
-    return issues;
-}
-/**
- * Statically compiles hooks from already-resolved effective plugins. It reads
- * manifest files to validate them but never executes a plugin executable.
- */
-export function compileHookRegistry(catalog, plugins) {
-    const validations = [];
-    const hooks = [];
-    const issues = [];
-    let order = 0;
-    for (const plugin of plugins) {
-        const artifact = validatePluginHookArtifact(plugin.root, plugin.manifest);
-        const pluginIssues = artifactIssues(plugin, artifact.issues);
-        let compiled = [];
-        if (pluginIssues.length === 0 && artifact.manifest !== undefined && artifact.executablePath !== undefined) {
-            const invalidTargets = targetIssues(plugin, artifact.manifest.hooks, catalog);
-            pluginIssues.push(...invalidTargets);
-            if (pluginIssues.length === 0) {
-                compiled = artifact.manifest.hooks.map((hook, declarationIndex) => Object.freeze({
-                    executable: artifact.executablePath,
-                    plugin: Object.freeze({ name: plugin.name, scope: plugin.scope, root: plugin.root }),
-                    target: hook.target,
-                    phase: hook.phase,
-                    op: hook.op,
-                    description: hook.description,
-                    effects: Object.freeze([...hook.effects]),
-                    declarationIndex,
-                    order: order++,
-                }));
-                hooks.push(...compiled);
-            }
-        }
-        validations.push(Object.freeze({
-            plugin,
-            ...(artifact.manifestPath === undefined ? {} : { manifestPath: artifact.manifestPath }),
-            ...(artifact.executablePath === undefined ? {} : { executablePath: artifact.executablePath }),
-            ...(artifact.manifest === undefined ? {} : { manifest: artifact.manifest }),
-            lifecycleCandidates: Object.freeze([...artifact.lifecycleCandidates]),
-            hooks: Object.freeze(compiled),
-            issues: Object.freeze(pluginIssues),
-        }));
-        issues.push(...pluginIssues);
-    }
-    const byTarget = new Map();
-    for (const hook of hooks) {
-        const entries = byTarget.get(hook.target);
-        if (entries === undefined)
-            byTarget.set(hook.target, [hook]);
-        else
-            entries.push(hook);
-    }
-    const plans = new Map();
-    for (const [target, entries] of byTarget) {
-        const replacements = entries.filter((entry) => entry.phase === 'replace');
-        if (replacements.length > 1) {
-            for (const replacement of replacements) {
-                issues.push(issue(replacement.plugin, {
-                    code: 'command_hook_collision',
-                    path: `hooks[${replacement.declarationIndex}]`,
-                    message: `multiple replacements target "${target}"`,
-                    received: replacements.map((entry) => `${entry.plugin.name}:${entry.op}`).join(', '),
-                    expected: 'exactly one replacement for this core leaf',
-                    next: 'Remove or change one replace declaration; before and after hooks may coexist with one replacement.',
-                }));
-            }
-        }
-        plans.set(target, Object.freeze({
-            target,
-            before: Object.freeze(entries.filter((entry) => entry.phase === 'before')),
-            after: Object.freeze(entries.filter((entry) => entry.phase === 'after').reverse()),
-            replacements: Object.freeze(replacements),
-        }));
-    }
-    return Object.freeze({
-        catalog,
-        hooks: Object.freeze(hooks),
-        plans,
-        validations: Object.freeze(validations),
-        issues: Object.freeze(issues),
-        valid: issues.length === 0,
-    });
-}
-/** Compiles lifecycle declarations from resolved plugins without loading the command tree. */
-export function compileLifecycleHookRegistry(plugins) {
-    const validations = [];
-    const hooks = [];
-    const issues = [];
-    let order = 0;
-    for (const plugin of plugins) {
-        const artifact = validatePluginHookArtifact(plugin.root, plugin.manifest);
-        const pluginIssues = artifactIssues(plugin, artifact.issues);
-        let compiled = [];
-        if (pluginIssues.length === 0 && artifact.manifest !== undefined && artifact.executablePath !== undefined) {
-            const lifecycle = artifact.manifest.schemaVersion === 2 ? artifact.manifest.lifecycle : [];
-            compiled = lifecycle.map((hook, declarationIndex) => Object.freeze({
-                executable: artifact.executablePath,
-                plugin: Object.freeze({ name: plugin.name, scope: plugin.scope, root: plugin.root }),
-                event: hook.event,
-                phase: hook.phase,
-                op: hook.op,
-                description: hook.description,
-                effects: Object.freeze([...hook.effects]),
-                declarationIndex,
-                order: order++,
-            }));
-            hooks.push(...compiled);
-        }
-        validations.push(Object.freeze({
-            plugin,
-            ...(artifact.manifestPath === undefined ? {} : { manifestPath: artifact.manifestPath }),
-            ...(artifact.executablePath === undefined ? {} : { executablePath: artifact.executablePath }),
-            ...(artifact.manifest === undefined ? {} : { manifest: artifact.manifest }),
-            lifecycleCandidates: Object.freeze([...artifact.lifecycleCandidates]),
-            hooks: Object.freeze([]),
-            issues: Object.freeze(pluginIssues),
-        }));
-        issues.push(...pluginIssues);
-    }
-    const plans = new Map();
-    for (const hook of hooks) {
-        const entries = plans.get(hook.event) ?? [];
-        plans.set(hook.event, Object.freeze([...entries, hook]));
-    }
-    return Object.freeze({
-        hooks: Object.freeze(hooks),
-        plans,
-        validations: Object.freeze(validations),
-        issues: Object.freeze(issues),
-        valid: issues.length === 0,
-    });
-}
-/** Discovers lifecycle hooks for one node's resolved cwd and profile. */
-export function discoverLifecycleHookRegistry(startDir, profileId) {
-    return compileLifecycleHookRegistry(effectiveHookPlugins(startDir, profileId));
-}
-/** Discovers and compiles the invocation-local effective registry. */
-export function discoverHookRegistry(catalog, startDir = process.cwd(), profileId) {
-    return compileHookRegistry(catalog, effectiveHookPlugins(startDir, profileId));
-}
-/** Compile the exact effective set a source candidate would create before its
- *  bytes replace the installed plugin. */
-export function discoverCandidateHookRegistry(catalog, candidate, scopeRoot, startDir = process.cwd(), profileId) {
-    return discoverCandidateHookRegistryForCandidates(catalog, [{ plugin: candidate, scopeRoot }], startDir, profileId);
-}
-/** Compile the exact effective set after all supplied source candidates take
- * their scope/name slots. This lets one transaction reject collisions introduced
- * only by the combined revision. */
-export function discoverCandidateHookRegistryForCandidates(catalog, candidates, startDir = process.cwd(), profileId) {
-    return compileHookRegistry(catalog, effectiveHookPluginsWithCandidates(candidates, startDir, profileId));
-}
-/** Fixture-friendly discovery seam; production callers should use discoverHookRegistry. */
-export function discoverHookRegistryInScopes(catalog, scopes) {
-    return compileHookRegistry(catalog, orderedPluginsInScopes(scopes));
-}
+var y=Object.defineProperty;var u=(t,n)=>y(t,"name",{value:n,configurable:!0});import{listInstalledPluginsInRoot as b}from"../resolver.js";import{projectScopeRoots as w,userScopeRoot as R}from"../scope.js";import{validatePluginHookArtifact as j}from"./artifact.js";function x(t){return t.manifest.hooks!==void 0||t.manifest.hookExecutable!==void 0}u(x,"hasHookDeclaration");function O(t){const n=new Set,s=[];for(const a of t){const p=b(a.scope,a.root).sort((c,r)=>c.name<r.name?-1:c.name>r.name?1:0);for(const c of p)n.has(c.name)||(n.add(c.name),c.enabled&&x(c)&&s.push(c))}return s}u(O,"orderedPluginsInScopes");function v(t=process.cwd(),n){return[...w(t,n).map(s=>({scope:"project",root:s})),{scope:"user",root:R()}]}u(v,"hookDiscoveryScopes");function z(t=process.cwd(),n){return O(v(t,n))}u(z,"effectiveHookPlugins");function H(t,n=process.cwd(),s){const a=new Set,p=[];for(const c of v(n,s)){const r=t.filter(e=>e.plugin.scope===c.scope&&e.scopeRoot===c.root),i=new Set(r.map(e=>e.plugin.name)),o=[...b(c.scope,c.root).filter(e=>!i.has(e.name)),...r.map(e=>e.plugin)];o.sort((e,l)=>e.name<l.name?-1:e.name>l.name?1:0);for(const e of o)a.has(e.name)||(a.add(e.name),e.enabled&&x(e)&&p.push(e))}return p}u(H,"effectiveHookPluginsWithCandidates");function h(t,n){return{...n,plugin:t.name,scope:t.scope}}u(h,"issue");function k(t,n){return n.map(s=>h(t,s))}u(k,"artifactIssues");function I(t,n,s){const a=[];return n.forEach((p,c)=>{s.has(p.target)||a.push(h(t,{code:"command_hook_target_invalid",path:`hooks[${c}].target`,message:`hook target "${p.target}" is not an eligible core returned-object leaf`,received:p.target,expected:"an exact eligible core leaf path",next:"Choose a current returned-object core leaf; pkg plugin, sys doctor, JSONL, passthrough, and UI/void surfaces are unavailable."}))}),a}u(I,"targetIssues");function g(t,n){const s=[],a=[],p=[];let c=0;for(const o of n){const e=j(o.root,o.manifest),l=k(o,e.issues);let f=[];if(l.length===0&&e.manifest!==void 0&&e.executablePath!==void 0){const d=I(o,e.manifest.hooks,t);l.push(...d),l.length===0&&(f=e.manifest.hooks.map((m,P)=>Object.freeze({executable:e.executablePath,plugin:Object.freeze({name:o.name,scope:o.scope,root:o.root}),target:m.target,phase:m.phase,op:m.op,description:m.description,effects:Object.freeze([...m.effects]),declarationIndex:P,order:c++})),a.push(...f))}s.push(Object.freeze({plugin:o,...e.manifestPath===void 0?{}:{manifestPath:e.manifestPath},...e.executablePath===void 0?{}:{executablePath:e.executablePath},...e.manifest===void 0?{}:{manifest:e.manifest},lifecycleCandidates:Object.freeze([...e.lifecycleCandidates]),hooks:Object.freeze(f),issues:Object.freeze(l)})),p.push(...l)}const r=new Map;for(const o of a){const e=r.get(o.target);e===void 0?r.set(o.target,[o]):e.push(o)}const i=new Map;for(const[o,e]of r){const l=e.filter(f=>f.phase==="replace");if(l.length>1)for(const f of l)p.push(h(f.plugin,{code:"command_hook_collision",path:`hooks[${f.declarationIndex}]`,message:`multiple replacements target "${o}"`,received:l.map(d=>`${d.plugin.name}:${d.op}`).join(", "),expected:"exactly one replacement for this core leaf",next:"Remove or change one replace declaration; before and after hooks may coexist with one replacement."}));i.set(o,Object.freeze({target:o,before:Object.freeze(e.filter(f=>f.phase==="before")),after:Object.freeze(e.filter(f=>f.phase==="after").reverse()),replacements:Object.freeze(l)}))}return Object.freeze({catalog:t,hooks:Object.freeze(a),plans:i,validations:Object.freeze(s),issues:Object.freeze(p),valid:p.length===0})}u(g,"compileHookRegistry");function C(t){const n=[],s=[],a=[];let p=0;for(const r of t){const i=j(r.root,r.manifest),o=k(r,i.issues);let e=[];o.length===0&&i.manifest!==void 0&&i.executablePath!==void 0&&(e=(i.manifest.schemaVersion===2?i.manifest.lifecycle:[]).map((f,d)=>Object.freeze({executable:i.executablePath,plugin:Object.freeze({name:r.name,scope:r.scope,root:r.root}),event:f.event,phase:f.phase,op:f.op,description:f.description,effects:Object.freeze([...f.effects]),declarationIndex:d,order:p++})),s.push(...e)),n.push(Object.freeze({plugin:r,...i.manifestPath===void 0?{}:{manifestPath:i.manifestPath},...i.executablePath===void 0?{}:{executablePath:i.executablePath},...i.manifest===void 0?{}:{manifest:i.manifest},lifecycleCandidates:Object.freeze([...i.lifecycleCandidates]),hooks:Object.freeze([]),issues:Object.freeze(o)})),a.push(...o)}const c=new Map;for(const r of s){const i=c.get(r.event)??[];c.set(r.event,Object.freeze([...i,r]))}return Object.freeze({hooks:Object.freeze(s),plans:c,validations:Object.freeze(n),issues:Object.freeze(a),valid:a.length===0})}u(C,"compileLifecycleHookRegistry");function D(t,n){return C(z(t,n))}u(D,"discoverLifecycleHookRegistry");function E(t,n=process.cwd(),s){return g(t,z(n,s))}u(E,"discoverHookRegistry");function N(t,n,s,a=process.cwd(),p){return S(t,[{plugin:n,scopeRoot:s}],a,p)}u(N,"discoverCandidateHookRegistry");function S(t,n,s=process.cwd(),a){return g(t,H(n,s,a))}u(S,"discoverCandidateHookRegistryForCandidates");function T(t,n){return g(t,O(n))}u(T,"discoverHookRegistryInScopes");export{g as compileHookRegistry,C as compileLifecycleHookRegistry,N as discoverCandidateHookRegistry,S as discoverCandidateHookRegistryForCandidates,E as discoverHookRegistry,T as discoverHookRegistryInScopes,D as discoverLifecycleHookRegistry,z as effectiveHookPlugins,v as hookDiscoveryScopes};

package/dist/core/command-hooks/help.js

@@ -1,18 +1 @@
-function attributedEffects(hook) {
-    const attribution = `plugin=${hook.plugin.name} phase=${hook.phase} op=${hook.op}`;
-    return hook.effects.map((effect) => `[${attribution}] ${effect}`);
-}
-/** Build a frozen help view whose Effects order matches the effective pipeline.
- *  Core help is never modified; all non-effects fields retain their references. */
-export function projectEffectiveLeafHelp(core, plan) {
-    const before = plan?.before.flatMap(attributedEffects) ?? [];
-    const replacement = plan?.replacements.length === 1 ? plan.replacements[0] : undefined;
-    const primary = replacement === undefined
-        ? core.effects
-        : attributedEffects(replacement);
-    const after = plan?.after.flatMap(attributedEffects) ?? [];
-    return Object.freeze({
-        ...core,
-        effects: Object.freeze([...before, ...primary, ...after]),
-    });
-}
+var s=Object.defineProperty;var n=(e,t)=>s(e,"name",{value:t,configurable:!0});function r(e){const t=`plugin=${e.plugin.name} phase=${e.phase} op=${e.op}`;return e.effects.map(f=>`[${t}] ${f}`)}n(r,"attributedEffects");function u(e,t){const f=t?.before.flatMap(r)??[],c=t?.replacements.length===1?t.replacements[0]:void 0,a=c===void 0?e.effects:r(c),p=t?.after.flatMap(r)??[];return Object.freeze({...e,effects:Object.freeze([...f,...a,...p])})}n(u,"projectEffectiveLeafHelp");export{u as projectEffectiveLeafHelp};

package/dist/core/command-hooks/index.js

@@ -1,7 +1 @@
-export { createCoreHookCatalog } from './catalog.js';
-export { projectEffectiveLeafHelp } from './help.js';
-export { compileHookRegistry, compileLifecycleHookRegistry, discoverCandidateHookRegistry, discoverHookRegistry, discoverHookRegistryInScopes, discoverLifecycleHookRegistry, effectiveHookPlugins, hookDiscoveryScopes, } from './discovery.js';
-export { validatePluginHookArtifact } from './artifact.js';
-export { hasDeclaredHooks, hookReport, HOOK_TRUST_WARNING } from './report.js';
-export { validateHookManifest, } from './schema.js';
-export { LIFECYCLE_EVENTS, isLifecycleEvent } from './lifecycle-catalog.js';
+import{createCoreHookCatalog as r}from"./catalog.js";import{projectEffectiveLeafHelp as t}from"./help.js";import{compileHookRegistry as s,compileLifecycleHookRegistry as f,discoverCandidateHookRegistry as a,discoverHookRegistry as p,discoverHookRegistryInScopes as k,discoverLifecycleHookRegistry as H,effectiveHookPlugins as l,hookDiscoveryScopes as v}from"./discovery.js";import{validatePluginHookArtifact as d}from"./artifact.js";import{hasDeclaredHooks as m,hookReport as R,HOOK_TRUST_WARNING as x}from"./report.js";import{validateHookManifest as E}from"./schema.js";import{LIFECYCLE_EVENTS as C,isLifecycleEvent as S}from"./lifecycle-catalog.js";export{x as HOOK_TRUST_WARNING,C as LIFECYCLE_EVENTS,s as compileHookRegistry,f as compileLifecycleHookRegistry,r as createCoreHookCatalog,a as discoverCandidateHookRegistry,p as discoverHookRegistry,k as discoverHookRegistryInScopes,H as discoverLifecycleHookRegistry,l as effectiveHookPlugins,m as hasDeclaredHooks,v as hookDiscoveryScopes,R as hookReport,S as isLifecycleEvent,t as projectEffectiveLeafHelp,E as validateHookManifest,d as validatePluginHookArtifact};

package/dist/core/command-hooks/lifecycle-catalog.js

@@ -1,9 +1 @@
-export const LIFECYCLE_CATALOG = {
-    'node:create': { phase: 'before', hookTimeoutMs: 5_000, eventBudgetMs: 10_000 },
-    'node:start': { phase: 'on', hookTimeoutMs: 5_000, eventBudgetMs: 10_000 },
-    'node:close': { phase: 'on', hookTimeoutMs: 120_000, eventBudgetMs: 180_000 },
-};
-export const LIFECYCLE_EVENTS = Object.freeze(Object.keys(LIFECYCLE_CATALOG));
-export function isLifecycleEvent(value) {
-    return Object.hasOwn(LIFECYCLE_CATALOG, value);
-}
+var n=Object.defineProperty;var t=(e,s)=>n(e,"name",{value:s,configurable:!0});const o={"node:create":{phase:"before",hookTimeoutMs:5e3,eventBudgetMs:1e4},"node:start":{phase:"on",hookTimeoutMs:5e3,eventBudgetMs:1e4},"node:close":{phase:"on",hookTimeoutMs:12e4,eventBudgetMs:18e4}},r=Object.freeze(Object.keys(o));function u(e){return Object.hasOwn(o,e)}t(u,"isLifecycleEvent");export{o as LIFECYCLE_CATALOG,r as LIFECYCLE_EVENTS,u as isLifecycleEvent};

package/dist/core/command-hooks/lifecycle-create.js

@@ -1,51 +1 @@
-import { crtrHome } from '../canvas/paths.js';
-import { nodeCreateRefused } from '../errors.js';
-import { discoverLifecycleHookRegistry } from './discovery.js';
-import { invokeBlockingLifecycleHooks } from './transport/exec-lifecycle.js';
-let nodeCreateGate = Promise.resolve();
-async function enterNodeCreateGate() {
-    let resolve;
-    const previous = nodeCreateGate;
-    nodeCreateGate = new Promise((release) => { resolve = release; });
-    await previous;
-    let released = false;
-    return () => {
-        if (released)
-            return;
-        released = true;
-        resolve();
-    };
-}
-function refusedCreateHookDiscovery(cwd, profileId) {
-    const registry = discoverLifecycleHookRegistry(cwd, profileId);
-    const plan = registry.plans.get('node:create') ?? [];
-    const failed = registry.validations.flatMap((validation) => validation.lifecycleCandidates
-        .filter((candidate) => candidate.event === 'node:create' && !plan.some((hook) => hook.plugin.name === validation.plugin.name && hook.declarationIndex === candidate.index))
-        .map((candidate) => ({
-        validation,
-        candidate,
-        issue: validation.issues.find((issue) => issue.path === `lifecycle[${candidate.index}]` || issue.path?.startsWith(`lifecycle[${candidate.index}].`)) ?? validation.issues[0],
-    })))[0];
-    if (failed === undefined)
-        return registry;
-    const { validation, candidate, issue } = failed;
-    throw nodeCreateRefused(`plugin "${validation.plugin.name}" lifecycle hook "${candidate.op}" for node:create could not be discovered: ${issue.message}`, `Refused by plugin ${validation.plugin.name}, op ${candidate.op}.`);
-}
-/** Admit one node creation and return the release that must run after its row exists. */
-export async function admitNodeCreate(create) {
-    const release = await enterNodeCreateGate();
-    try {
-        const registry = refusedCreateHookDiscovery(create.cwd, create.profile);
-        const refusal = await invokeBlockingLifecycleHooks(registry.plans.get('node:create') ?? [], {
-            create,
-            runtime: { canvasHome: crtrHome(), profile: create.profile },
-        });
-        if (refusal !== null)
-            throw nodeCreateRefused(refusal.message, refusal.next);
-        return release;
-    }
-    catch (error) {
-        release();
-        throw error;
-    }
-}
+var m=Object.defineProperty;var l=(e,r)=>m(e,"name",{value:r,configurable:!0});import{crtrHome as g}from"../canvas/paths.js";import{nodeCreateRefused as u}from"../errors.js";import{discoverLifecycleHookRegistry as y}from"./discovery.js";import{invokeBlockingLifecycleHooks as w}from"./transport/exec-lifecycle.js";let p=Promise.resolve();async function h(){let e;const r=p;p=new Promise(t=>{e=t}),await r;let o=!1;return()=>{o||(o=!0,e())}}l(h,"enterNodeCreateGate");function v(e,r){const o=y(e,r),t=o.plans.get("node:create")??[],a=o.validations.flatMap(s=>s.lifecycleCandidates.filter(n=>n.event==="node:create"&&!t.some(i=>i.plugin.name===s.plugin.name&&i.declarationIndex===n.index)).map(n=>({validation:s,candidate:n,issue:s.issues.find(i=>i.path===`lifecycle[${n.index}]`||i.path?.startsWith(`lifecycle[${n.index}].`))??s.issues[0]})))[0];if(a===void 0)return o;const{validation:c,candidate:f,issue:d}=a;throw u(`plugin "${c.plugin.name}" lifecycle hook "${f.op}" for node:create could not be discovered: ${d.message}`,`Refused by plugin ${c.plugin.name}, op ${f.op}.`)}l(v,"refusedCreateHookDiscovery");async function R(e){const r=await h();try{const o=v(e.cwd,e.profile),t=await w(o.plans.get("node:create")??[],{create:e,runtime:{canvasHome:g(),profile:e.profile}});if(t!==null)throw u(t.message,t.next);return r}catch(o){throw r(),o}}l(R,"admitNodeCreate");export{R as admitNodeCreate};