@lidtop/loadout 0.3.1 → 0.4.0

package/dist/review.js

@@ -0,0 +1,346 @@
+import { createPrompt, isEnterKey, isSpaceKey, useEffect, useKeypress, useState, } from '@inquirer/core';
+import { createTwoFilesPatch } from 'diff';
+import { stripVTControlCharacters, styleText } from 'node:util';
+import stringWidth from 'string-width';
+import { kitSource } from './schema.js';
+import { reasons, resolveKits } from './resolve.js';
+import { hasChanges } from './storage.js';
+import { suspendEscapeCancellation } from './terminal.js';
+// Compare effective kits, not just checkboxes: a deselected dependency may stay enabled.
+export function selectionSummary({ target, state, update, }) {
+    const catalog = target.catalog;
+    const saved = target.state ?? { schemaVersion: 1, selected: [], answers: {} };
+    const old = new Set([
+        ...resolveKits(catalog, saved.selected.filter((id) => catalog.kits.has(id) && catalog.kits.get(id)?.ready !== false)),
+        ...saved.selected,
+    ]);
+    const next = new Set(resolveKits(catalog, state.selected));
+    return [...new Set([...old, ...next])].sort().map((id) => {
+        const kit = catalog.kits.get(id);
+        const explicitChanged = saved.selected.includes(id) !== state.selected.includes(id);
+        const answerKeys = Object.keys(kit?.questions ?? {}).sort();
+        const configured = next.has(id) &&
+            answerKeys.some((key) => saved.answers[id]?.[key] !== state.answers[id]?.[key]);
+        const effect = !next.has(id)
+            ? 'Remove'
+            : !old.has(id)
+                ? 'Add'
+                : update.includes(id)
+                    ? 'Update'
+                    : configured
+                        ? 'Configure'
+                        : 'Keep';
+        const notes = [];
+        if (next.has(id) && !state.selected.includes(id))
+            notes.push(`${saved.selected.includes(id) ? 'still required' : 'dependency'} of ${reasons(catalog, state.selected, id).join(', ')}`);
+        else if (effect === 'Keep' && explicitChanged)
+            notes.push('chosen directly');
+        if (effect === 'Update' && kit?.external)
+            notes.push(`${kit.pinned?.ref.slice(0, 7) ?? 'saved'} → ${kit.external.ref.slice(0, 7)}`);
+        if (next.has(id))
+            for (const key of answerKeys) {
+                const answer = state.answers[id]?.[key];
+                if (answer !== undefined)
+                    notes.push(`${key === 'placement' ? 'Install as' : key.replaceAll('-', ' ')}: ${answer}`);
+            }
+        if (kit && kitSource(kit) !== 'Repository')
+            notes.push(kitSource(kit));
+        return {
+            id,
+            effect,
+            notes,
+            unchanged: effect === 'Keep' && !explicitChanged,
+        };
+    });
+}
+const outputChanges = (plan) => plan.changes.filter((change) => change.kind !== 'unchanged' &&
+    !change.path.startsWith('.loadout-personal/'));
+export function reviewRows(selections, expanded) {
+    const rows = [];
+    const summaries = selections.map(selectionSummary);
+    if (!selections.some(({ plan }) => plan && hasChanges(plan)))
+        rows.push({ text: 'No changes to apply' });
+    selections.forEach(({ target, plan }, scope) => {
+        const kits = summaries[scope];
+        rows.push({
+            text: `${target.label} · ${target.root}`,
+            scope,
+            heading: true,
+        });
+        const changed = kits.filter((kit) => !kit.unchanged);
+        const unchanged = kits.filter((kit) => kit.unchanged);
+        const kitRow = (kit) => ({
+            text: `  ${kit.effect.padEnd(9)} ${kit.id}${kit.notes.length ? ` · ${kit.notes.join(' · ')}` : ''}`,
+            scope,
+        });
+        rows.push(...changed.map(kitRow));
+        if (unchanged.length) {
+            rows.push({
+                text: `  ${expanded.includes(scope) ? '▾' : '▸'} Unchanged (${unchanged.length})`,
+                scope,
+                expand: scope,
+            });
+            if (expanded.includes(scope))
+                rows.push(...unchanged.map(kitRow));
+        }
+        if (!kits.length)
+            rows.push({ text: '  No kits selected', scope });
+        if (plan) {
+            const changes = outputChanges(plan);
+            const counts = ['create', 'update', 'delete'].flatMap((kind) => {
+                const count = changes.filter((change) => change.kind === kind).length;
+                return count
+                    ? [`${count} ${kind === 'delete' ? 'remove' : kind}`]
+                    : [];
+            });
+            if (counts.length)
+                rows.push({ text: `  Files: ${counts.join(' · ')}`, scope });
+            else if (hasChanges(plan))
+                rows.push({ text: '  Settings only', scope });
+            if (plan.adopted?.length)
+                rows.push({
+                    text: `  Existing content kept: ${plan.adopted.join(', ')}`,
+                    scope,
+                });
+            for (const skipped of plan.skippedInstructions ?? [])
+                rows.push({
+                    text: `  Skipped instructions · ${skipped.kits.join(', ')}: ${skipped.reason} (${skipped.paths.join(', ')})`,
+                    scope,
+                    warning: true,
+                });
+            for (const id of plan.kitsWithoutOutputs ?? [])
+                rows.push({
+                    text: `  ${id}: no agent outputs will be applied`,
+                    scope,
+                    warning: true,
+                });
+        }
+        rows.push({ text: '' });
+    });
+    return rows;
+}
+function fileRows(selections) {
+    return selections.flatMap(({ target, state, update, plan }, scope) => {
+        const rows = [
+            { text: `${target.label} · ${target.root}`, scope, heading: true },
+        ];
+        for (const id of resolveKits(target.catalog, state.selected)) {
+            const kit = target.catalog.kits.get(id);
+            if (!kit.external)
+                continue;
+            const source = update.includes(id)
+                ? kit.external
+                : (kit.pinned ?? kit.external);
+            rows.push({
+                text: `${id}: ${source.repo}@${source.ref} · license: ${source.license}`,
+                scope,
+            });
+        }
+        const files = plan ? outputChanges(plan) : [];
+        rows.push(...files.map((file) => ({
+            text: `${file.kind === 'create' ? '+' : file.kind === 'delete' ? '-' : '~'} ${file.path}`,
+            scope,
+            file,
+        })));
+        if (!files.length)
+            rows.push({ text: 'No agent file changes', scope });
+        rows.push({ text: '' });
+        return rows;
+    });
+}
+function diffRows(row) {
+    const file = row.file;
+    const before = file.before?.content ?? Buffer.alloc(0);
+    const after = file.after?.content ?? Buffer.alloc(0);
+    const header = { text: file.path, scope: row.scope, heading: true };
+    if (before.equals(after))
+        return [header, { text: 'File mode changed; content is unchanged.' }];
+    if (before.length + after.length > 200_000 ||
+        before.includes(0) ||
+        after.includes(0))
+        return [
+            header,
+            { text: 'Binary or large content; inspect the source for details.' },
+        ];
+    return [
+        header,
+        ...createTwoFilesPatch(`a/${file.path}`, `b/${file.path}`, before.toString('utf8'), after.toString('utf8'), undefined, undefined, { context: 3 })
+            .split('\n')
+            .map((text) => ({ text, scope: row.scope })),
+    ];
+}
+export function wrapReviewText(value, width) {
+    const text = stripVTControlCharacters(value).replace(/[\x00-\x1f\x7f]/g, ' ');
+    const lines = [];
+    let line = '';
+    for (const character of text) {
+        if (line && stringWidth(line + character) > width) {
+            lines.push(line);
+            line = '';
+        }
+        line += character;
+    }
+    lines.push(line);
+    return lines;
+}
+const screen = createPrompt((config, done) => {
+    const [expanded, setExpanded] = useState([]);
+    const [view, setView] = useState('summary');
+    const [diff, setDiff] = useState([]);
+    const [active, setActive] = useState(undefined);
+    const [lastContent, setLastContent] = useState(0);
+    const [summaryCursor, setSummaryCursor] = useState(0);
+    const [fileCursor, setFileCursor] = useState(0);
+    const [size, setSize] = useState({
+        columns: process.stdout.columns || 80,
+        rows: process.stdout.rows || 24,
+    });
+    useEffect(() => {
+        const resize = () => setSize({
+            columns: process.stdout.columns || 80,
+            rows: process.stdout.rows || 24,
+        });
+        process.stdout.on('resize', resize);
+        return () => {
+            process.stdout.off('resize', resize);
+        };
+    }, []);
+    const width = Math.max(16, (config.columns ?? size.columns) - 4);
+    const changed = config.selections.some(({ plan }) => plan && hasChanges(plan));
+    const actions = view !== 'summary'
+        ? [
+            {
+                label: view === 'diff' ? 'Back to files' : 'Back to review',
+                value: 'close',
+            },
+        ]
+        : [
+            { label: 'Back to kits', value: 'back' },
+            { label: 'View files', value: 'files' },
+            {
+                label: changed ? 'Apply changes' : 'Done',
+                value: changed ? 'apply' : 'done',
+            },
+        ];
+    const content = view === 'diff'
+        ? diff
+        : view === 'files'
+            ? fileRows(config.selections)
+            : reviewRows(config.selections, expanded);
+    const rows = content.flatMap((row) => wrapReviewText(row.text, width - 2).map((text, index) => ({
+        ...row,
+        text,
+        ...(index ? { expand: undefined, file: undefined } : {}),
+    })));
+    const cursor = Math.min(active ?? rows.length + actions.length - 1, rows.length + actions.length - 1);
+    const focus = (index) => {
+        setActive(index);
+        if (index < rows.length)
+            setLastContent(index);
+    };
+    const pageSize = Math.min(rows.length, Math.max(2, (config.rows ?? size.rows) - actions.length - 5));
+    const start = Math.max(0, Math.min((cursor < rows.length ? cursor : lastContent) - Math.floor(pageSize / 2), rows.length - pageSize));
+    const back = () => {
+        if (view === 'diff') {
+            setView('files');
+            setActive(fileCursor);
+        }
+        else if (view === 'files') {
+            setView('summary');
+            setActive(summaryCursor);
+        }
+        else
+            done('back');
+    };
+    useKeypress((key, rl) => {
+        rl.clearLine(0);
+        if (key.name === 'escape') {
+            back();
+            return;
+        }
+        if (key.name === 'tab') {
+            const index = cursor < rows.length
+                ? key.shift
+                    ? actions.length
+                    : -1
+                : cursor - rows.length;
+            setActive(rows.length +
+                ((index + (key.shift ? -1 : 1) + actions.length) % actions.length));
+        }
+        else if (key.name === 'home')
+            focus(0);
+        else if (key.name === 'end')
+            setActive(rows.length + actions.length - 1);
+        else if (['up', 'down', 'pageup', 'pagedown'].includes(key.name)) {
+            const step = key.name.startsWith('page') ? pageSize : 1;
+            const backwards = key.name === 'up' || key.name === 'pageup';
+            const length = rows.length + actions.length;
+            focus((cursor + ((backwards ? -step : step) % length) + length) % length);
+        }
+        else if (isEnterKey(key) || isSpaceKey(key)) {
+            const action = actions[cursor - rows.length];
+            if (action?.value === 'close')
+                back();
+            else if (action?.value === 'files') {
+                setSummaryCursor(cursor);
+                setView('files');
+                setActive(0);
+                setLastContent(0);
+            }
+            else if (action)
+                done(action.value);
+            else {
+                const row = rows[cursor];
+                if (row?.expand !== undefined)
+                    setExpanded(expanded.includes(row.expand)
+                        ? expanded.filter((scope) => scope !== row.expand)
+                        : [...expanded, row.expand]);
+                if (row?.file) {
+                    setFileCursor(cursor);
+                    setDiff(diffRows(row));
+                    setView('diff');
+                    setActive(0);
+                    setLastContent(0);
+                }
+            }
+        }
+    });
+    const accent = (text) => styleText(config.selections.every(({ target }) => target.global)
+        ? 'magenta'
+        : 'cyan', text);
+    const title = view === 'files'
+        ? 'Files · Enter to inspect a diff'
+        : view === 'diff'
+            ? 'File diff'
+            : 'Review changes';
+    const page = rows.slice(start, start + pageSize).map((row, index) => {
+        const global = row.scope !== undefined && config.selections[row.scope]?.target.global;
+        const text = row.warning
+            ? styleText('yellow', row.text)
+            : row.heading
+                ? styleText(global ? 'magenta' : 'cyan', styleText('bold', row.text))
+                : row.text;
+        return `  ${start + index === cursor ? styleText(global ? 'magenta' : 'cyan', '›') : ' '} ${text}`;
+    });
+    return [
+        `  ${accent(styleText('bold', title))}`,
+        '',
+        ...page,
+        ...actions.map((action, index) => `  ${cursor === rows.length + index ? accent('›') : ' '} ${cursor === rows.length + index ? accent(`[ ${action.label} ]`) : `[ ${action.label} ]`}`),
+        `  ${styleText('dim', `↑↓ move · Tab actions · Enter select · Esc back${rows.length > pageSize ? ` · ${start + 1}–${Math.min(start + pageSize, rows.length)}/${rows.length}` : ''}`)}`,
+        '\u001b[?25l',
+    ]
+        .map((line) => stringWidth(line) > width + 4
+        ? wrapReviewText(line, width + 4)[0]
+        : line)
+        .join('\n');
+});
+export async function reviewScreen(config, context) {
+    const restore = suspendEscapeCancellation(context?.input ?? process.stdin);
+    try {
+        return await screen(config, { ...context, clearPromptOnDone: true });
+    }
+    finally {
+        restore();
+    }
+}

package/dist/schema.d.ts

@@ -83,8 +83,9 @@ export declare const stateSchema: z.ZodObject<{
     selected: z.ZodArray<z.ZodString>;
     answers: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>>;
 }, z.core.$strict>;
-export declare const ownedSchema: z.ZodObject<{
+export declare const generatedSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
+    installedAt: z.ZodRecord<z.ZodString, z.ZodISODateTime>;
     files: z.ZodRecord<z.ZodString, z.ZodObject<{
         hash: z.ZodString;
         mode: z.ZodUnion<readonly [z.ZodLiteral<420>, z.ZodLiteral<493>]>;
@@ -93,6 +94,7 @@ export declare const ownedSchema: z.ZodObject<{
 export type Question = z.infer<typeof question>;
 export type Answer = boolean | string;
 export type State = z.infer<typeof stateSchema>;
+export type Generated = z.infer<typeof generatedSchema>;
 export type Kit = z.infer<typeof kitSchema> & {
     directory: string;
     external?: ExternalSource;

package/dist/schema.js

@@ -111,9 +111,10 @@ export const stateSchema = z
     answers: z.record(idSchema, z.record(idSchema, z.union([z.boolean(), z.string()]))),
 })
     .strict();
-export const ownedSchema = z
+export const generatedSchema = z
     .object({
     schemaVersion: z.literal(1),
+    installedAt: z.record(idSchema, z.iso.datetime()),
     files: z.record(z.string(), z
         .object({
         hash: z.string().regex(/^[a-f0-9]{64}$/),

package/dist/setup.d.ts

@@ -0,0 +1,9 @@
+import { type TargetSelection } from './picker.js';
+import { type PromptContext } from './interactive.js';
+import { type FetchBytes } from './external.js';
+import { type Target } from './targets.js';
+export declare function interactive(targets: Target[], initial?: number, options?: {
+    context?: PromptContext;
+    offline?: boolean;
+    fetch?: FetchBytes;
+}): Promise<TargetSelection[]>;

package/dist/setup.js

@@ -0,0 +1,120 @@
+import { targetPicker, } from './picker.js';
+import { BackNavigation, configureSelection, confirmAdoption, selectUpdates, retryReview, } from './interactive.js';
+import { renderWithExternal, } from './external.js';
+import { applyAll, plan } from './storage.js';
+import { reviewScreen, } from './review.js';
+import { prepareScreen } from './prepare.js';
+import { suspendEscapeCancellation } from './terminal.js';
+export async function interactive(targets, initial = 0, options = {}) {
+    if (!options.context && (!process.stdin.isTTY || !process.stdout.isTTY))
+        throw new Error('Interactive setup needs a terminal. Use loadout enable <kit>, then loadout apply.');
+    const session = {};
+    const drafts = new Map();
+    const cache = new Map();
+    const context = { ...options.context, clearPromptOnDone: true };
+    for (;;) {
+        const chosen = await targetPicker({ targets, initial, session }, context);
+        const selections = chosen.map(({ target, state }) => {
+            const previous = drafts.get(target);
+            const draft = {
+                target,
+                state: structuredClone({
+                    ...state,
+                    answers: previous?.state.answers ?? state.answers,
+                }),
+                update: previous?.update ?? [],
+            };
+            drafts.set(target, draft);
+            return draft;
+        });
+        for (const [target, draft] of drafts) {
+            if (selections.some((selection) => selection.target === target))
+                continue;
+            // The picker omits inactive scopes whose checkboxes match saved state.
+            // They can still have draft answers, but must use the latest checkboxes.
+            draft.state.selected = [
+                ...(session.snapshot?.selections[targets.indexOf(target)] ??
+                    draft.state.selected),
+            ];
+            if (draft.update.length ||
+                JSON.stringify(draft.state.answers) !==
+                    JSON.stringify(target.state?.answers ?? {}))
+                selections.push(draft);
+        }
+        selections.sort((a, b) => targets.indexOf(a.target) - targets.indexOf(b.target));
+        const restoreEscape = suspendEscapeCancellation(context.input ?? process.stdin);
+        try {
+            for (;;) {
+                try {
+                    // Finish questions for every destination before starting any downloads.
+                    for (const selection of selections) {
+                        const { target, state } = selection;
+                        selection.state = await configureSelection(target, state, context, (kit, key, answer) => {
+                            state.answers[kit] ??= {};
+                            state.answers[kit][key] = answer;
+                        });
+                        selection.update = await selectUpdates(target.catalog, selection.state, options.offline, context, {
+                            message: `${target.label} · Choose catalog updates (Enter keeps your choices)`,
+                            selected: selection.update,
+                            quiet: true,
+                        });
+                    }
+                    const prepared = await prepareScreen({
+                        selections,
+                        run: async (progress, retry, signal) => {
+                            const prepared = [];
+                            for (const [scope, selection] of selections.entries()) {
+                                const { target, state, update } = selection;
+                                progress(scope, 'Preparing kits…');
+                                const rendered = await renderWithExternal(target.catalog, state, {
+                                    offline: options.offline,
+                                    fetch: options.fetch,
+                                    update,
+                                    cache,
+                                    signal,
+                                    onFetch: (id) => progress(scope, `Downloading ${id}…`),
+                                    onRetry: (id) => progress(scope, `Retrying ${id}…`),
+                                    onReady: (id) => progress(scope, `${id} · Ready`),
+                                    retry: (id, error) => retry(scope, id, error),
+                                });
+                                signal.throwIfAborted();
+                                progress(scope, 'Checking file changes…');
+                                prepared.push({
+                                    ...selection,
+                                    plan: plan(target.catalog, state, rendered, {
+                                        adopt: true,
+                                    }),
+                                });
+                                progress(scope, 'Ready');
+                            }
+                            return prepared;
+                        },
+                    }, context);
+                    for (const { target, plan } of prepared) {
+                        if (plan.adopted?.length &&
+                            !(await confirmAdoption(plan.adopted, context, target.label)))
+                            throw new BackNavigation();
+                    }
+                    const action = await reviewScreen({ selections: prepared }, context);
+                    if (action === 'back')
+                        break;
+                    if (action === 'apply')
+                        applyAll(prepared.map(({ plan }) => plan));
+                    return selections.map(({ target, state }) => ({ target, state }));
+                }
+                catch (failure) {
+                    if (failure instanceof BackNavigation)
+                        break;
+                    if (failure instanceof Error &&
+                        ['ExitPromptError', 'AbortPromptError'].includes(failure.name))
+                        throw failure;
+                    if (!(await retryReview(failure, context)))
+                        break;
+                }
+            }
+        }
+        finally {
+            restoreEscape();
+        }
+    }
+}

package/dist/storage.d.ts

@@ -1,5 +1,5 @@
 import { type IgnoreTarget } from './ignore.js';
-import { type Catalog, type State } from './schema.js';
+import { type Catalog, type State, type Generated } from './schema.js';
 import { type FileContent, type Rendered } from './render.js';
 export type Change = {
     path: string;
@@ -10,6 +10,7 @@ export type Change = {
 export type Plan = {
     root: string;
     changes: Change[];
+    installing?: string[];
     adopted?: string[];
     skippedInstructions?: {
         paths: string[];
@@ -27,6 +28,7 @@ export type Plan = {
     };
 };
 export declare function loadState(catalog: Catalog): State;
+export declare function loadGenerated(root: string): Generated;
 type ExcludePlan = {
     target: IgnoreTarget;
     paths: string[];

package/dist/storage.js

@@ -6,7 +6,8 @@ import path from 'node:path';
 import { createHash, randomUUID } from 'node:crypto';
 import { execFileSync } from 'node:child_process';
 import { exists, json, readOptional, safePath, walk, portableMode, } from './fs.js';
-import { parse, ownedSchema, stateSchema, } from './schema.js';
+import { parse, generatedSchema, stateSchema, } from './schema.js';
+import { resolveKits } from './resolve.js';
 const hash = (content) => createHash('sha256').update(content).digest('hex');
 export function loadState(catalog) {
     const raw = readOptional(catalog.root, '.loadout-personal/local.json');
@@ -14,6 +15,12 @@ export function loadState(catalog) {
         ? parse(stateSchema, JSON.parse(raw.toString()), '.loadout-personal/local.json')
         : { schemaVersion: 1, selected: [], answers: {} };
 }
+export function loadGenerated(root) {
+    const raw = readOptional(root, '.loadout-personal/generated.json');
+    return raw
+        ? parse(generatedSchema, JSON.parse(raw.toString()), '.loadout-personal/generated.json')
+        : { schemaVersion: 1, installedAt: {}, files: {} };
+}
 function snapshot(root, relative) {
     const content = readOptional(root, relative);
     return content === undefined
@@ -71,10 +78,12 @@ function trackedFiles(root) {
 }
 export function plan(catalog, state, rendered, options = {}) {
     const root = catalog.root;
-    const raw = readOptional(root, '.loadout-personal/generated.json');
-    const owned = raw
-        ? parse(ownedSchema, JSON.parse(raw.toString()), '.loadout-personal/generated.json').files
-        : {};
+    const generated = loadGenerated(root);
+    const owned = generated.files;
+    const enabled = resolveKits(catalog, state.selected).sort();
+    const installing = enabled.filter((id) => !Object.hasOwn(generated.installedAt, id));
+    const plannedAt = new Date().toISOString();
+    const installedAt = Object.fromEntries(enabled.map((id) => [id, generated.installedAt[id] ?? plannedAt]));
     const tracked = trackedFiles(root);
     const skippedInstructions = [];
     const retainedKits = new Set(rendered.skillKits);
@@ -149,7 +158,10 @@ export function plan(catalog, state, rendered, options = {}) {
         .map(([p, f]) => [p, { hash: hash(f.content), mode: f.mode }]));
     const metadata = new Map([
         ['.loadout-personal/local.json', json(state)],
-        ['.loadout-personal/generated.json', json({ schemaVersion: 1, files })],
+        [
+            '.loadout-personal/generated.json',
+            json({ schemaVersion: 1, installedAt, files }),
+        ],
     ]);
     if (rendered.external) {
         const current = readOptional(root, '.loadout-personal/external.json');
@@ -175,6 +187,7 @@ export function plan(catalog, state, rendered, options = {}) {
     return {
         root,
         changes,
+        installing,
         adopted: adoption.adopted,
         skippedInstructions,
         kitsWithoutOutputs,
@@ -321,9 +334,23 @@ export function applyAll(plans) {
         for (const { root, change } of writes)
             if (!equal(snapshot(root, change.path), change.before))
                 throw new Error(`File changed since preview: ${change.path}. Run the command again.`);
-        for (const { root, change } of writes) {
+        const installedAt = new Date().toISOString();
+        for (const { root, change: planned } of writes) {
+            let change = planned;
             if (change.kind === 'unchanged')
                 continue;
+            const installing = plans.find((plan) => plan.root === root)?.installing;
+            if (change.path === '.loadout-personal/generated.json' &&
+                change.after &&
+                installing?.length) {
+                const generated = parse(generatedSchema, JSON.parse(change.after.content.toString()), change.path);
+                for (const id of installing)
+                    generated.installedAt[id] = installedAt;
+                change = {
+                    ...change,
+                    after: { ...change.after, content: json(generated) },
+                };
+            }
             if (change.after)
                 writeAtomic(root, change.path, change.after);
             else

package/dist/targets.d.ts

@@ -5,6 +5,7 @@ export type Target = {
     global: boolean;
     catalog?: Catalog;
     state?: State;
+    installedAt?: Record<string, string>;
     error?: string;
 };
 export declare function loadTarget(root: string, global: boolean): Target;

package/dist/targets.js

@@ -1,6 +1,6 @@
 import { loadCatalog } from './catalog.js';
 import { readExternal } from './external.js';
-import { loadState } from './storage.js';
+import { loadGenerated, loadState } from './storage.js';
 export function loadTarget(root, global) {
     const target = {
         root,
@@ -15,7 +15,12 @@ export function loadTarget(root, global) {
             if (kit?.external)
                 kit.pinned = snapshot.source;
         }
-        return { ...target, catalog, state: loadState(catalog) };
+        return {
+            ...target,
+            catalog,
+            state: loadState(catalog),
+            installedAt: loadGenerated(root).installedAt,
+        };
     }
     catch (error) {
         return { ...target, error: error.message };

package/dist/terminal.d.ts

@@ -1 +1,2 @@
+export declare function suspendEscapeCancellation(input: NodeJS.ReadableStream): () => void;
 export declare function prepareInput(input: NodeJS.ReadableStream): void;