@aryacode/dsh-engineering 0.0.0-stage → 0.4.0

package/vendor/ftview/lib/model.js

@@ -0,0 +1,267 @@
+/**
+ * FactoryTalk View ME export scanning and parsing.
+ *
+ * Only documented text exports are read: display XML and the semicolon-separated
+ * HMI tag CSV. Native MER/MED databases are not decoded or rewritten. A display
+ * contributes its root identity and its named objects; the tag CSV contributes
+ * typed rows, and its structural problems are reported rather than hidden.
+ *
+ * @module dsh-engineering-ftview/model
+ */
+import { createHash } from 'node:crypto';
+import { readdir } from 'node:fs/promises';
+import { XMLParser } from 'fast-xml-parser';
+import { EngineeringError } from "./core.js";
+/** Attribute prefix the XML parser uses. */
+const ATTRIBUTE = '@_';
+/** Split one semicolon-separated CSV line, honouring double quotes. */
+export function splitCsv(line) {
+    const cells = [];
+    let current = '';
+    let quoted = false;
+    for (let index = 0; index < line.length; index += 1) {
+        const character = line[index];
+        if (quoted) {
+            if (character === '"') {
+                if (line[index + 1] === '"') {
+                    current += '"';
+                    index += 1;
+                }
+                else {
+                    quoted = false;
+                }
+            }
+            else {
+                current += character;
+            }
+        }
+        else if (character === '"') {
+            quoted = true;
+        }
+        else if (character === ';') {
+            cells.push(current);
+            current = '';
+        }
+        else {
+            current += character;
+        }
+    }
+    cells.push(current);
+    return cells;
+}
+/** Decode bytes as UTF-8, dropping a byte-order mark. */
+function decode(bytes) {
+    const text = new TextDecoder('utf-8').decode(bytes);
+    return text.charCodeAt(0) === 0xfeff ? text.slice(1) : text;
+}
+/**
+ * Parse the HMI tag CSV.
+ *
+ * @param text - Whole CSV file.
+ * @returns Rows plus structural errors; a file with no `###002` marker yields no rows.
+ */
+export function parseTagCsv(text) {
+    const lines = text.split(/\r?\n/);
+    const versionLine = lines.findIndex(line => line.includes('###002'));
+    if (versionLine < 0) {
+        return { rows: [], errors: ['Unsupported tag CSV: the `###002` version line is missing.'] };
+    }
+    const headerIndex = lines.findIndex((line, index) => index > versionLine && line.trim() !== '');
+    if (headerIndex < 0) {
+        return { rows: [], errors: ['Unsupported tag CSV: no header row follows the version line.'] };
+    }
+    const header = splitCsv(lines[headerIndex]).map(cell => cell.trim());
+    const nameIndex = header.indexOf('Tag Name');
+    if (nameIndex < 0) {
+        return { rows: [], errors: ['Unsupported tag CSV: the header has no `Tag Name` column.'] };
+    }
+    const descriptionIndex = header.indexOf('Tag Description');
+    const typeIndex = header.indexOf('Tag Type');
+    const rows = [];
+    const errors = [];
+    const seen = new Set();
+    for (let index = headerIndex + 1; index < lines.length; index += 1) {
+        const line = lines[index];
+        if (line.trim() === '')
+            continue;
+        const cells = splitCsv(line);
+        if (cells.length < header.length) {
+            errors.push(`Row ${index + 1}: expected ${header.length} columns, found ${cells.length}.`);
+            continue;
+        }
+        const raw = {};
+        header.forEach((column, columnIndex) => {
+            if (column !== '')
+                raw[column] = (cells[columnIndex] ?? '').trim();
+        });
+        const name = (cells[nameIndex] ?? '').trim();
+        if (name === '') {
+            errors.push(`Row ${index + 1}: empty Tag Name.`);
+            continue;
+        }
+        if (seen.has(name))
+            errors.push(`Row ${index + 1}: duplicate tag name ${JSON.stringify(name)}.`);
+        seen.add(name);
+        rows.push({
+            name,
+            description: descriptionIndex >= 0 ? (cells[descriptionIndex] ?? '').trim() : '',
+            type: typeIndex >= 0 ? (cells[typeIndex] ?? '').trim() : '',
+            raw,
+        });
+    }
+    return { rows, errors };
+}
+/** The parser used for display XML, preserving attributes and order-independent names. */
+const PARSER = new XMLParser({
+    ignoreAttributes: false,
+    attributeNamePrefix: ATTRIBUTE,
+    trimValues: true,
+    parseTagValue: false,
+    isArray: () => false,
+});
+/** Strip the attribute prefix from one attribute bag. */
+function attributesOf(node) {
+    const attributes = {};
+    for (const [key, value] of Object.entries(node)) {
+        if (key.startsWith(ATTRIBUTE) && typeof value === 'string')
+            attributes[key.slice(ATTRIBUTE.length)] = value;
+        if (key.startsWith(ATTRIBUTE) && typeof value === 'number')
+            attributes[key.slice(ATTRIBUTE.length)] = String(value);
+    }
+    return attributes;
+}
+/** Collect one element and its descendants as display objects. */
+function collectObjects(node, type, out, depth) {
+    if (depth > 8 || node === null || typeof node !== 'object' || Array.isArray(node))
+        return;
+    const record = node;
+    const attributes = attributesOf(record);
+    const named = attributes.name ?? attributes.Name;
+    out.push({ type, ...(named === undefined ? {} : { name: named }), attributes });
+    for (const [key, value] of Object.entries(record)) {
+        if (key.startsWith(ATTRIBUTE) || key === '#text')
+            continue;
+        if (Array.isArray(value)) {
+            for (const item of value)
+                collectObjects(item, key, out, depth + 1);
+        }
+        else {
+            collectObjects(value, key, out, depth + 1);
+        }
+    }
+}
+/**
+ * Parse one display XML file.
+ *
+ * @param file - Relative path inside the export folder.
+ * @param text - Whole XML file.
+ * @returns The display, or the parse error with a synthetic entry.
+ */
+export function parseDisplay(file, text) {
+    const fallbackName = file.replace(/\\/gu, '/').split('/').pop()?.replace(/\.xml$/iu, '') ?? file;
+    try {
+        const parsed = PARSER.parse(text);
+        const rootKey = Object.keys(parsed).find(key => !key.startsWith('?'));
+        if (rootKey === undefined)
+            return { file, name: fallbackName, objects: [], parseError: 'The file has no root element.' };
+        const rootNode = parsed[rootKey];
+        if (!/display/iu.test(rootKey)) {
+            return { file, name: fallbackName, objects: [], parseError: `Root element ${rootKey} is not an ME display.` };
+        }
+        const root = (rootNode ?? {});
+        const attributes = attributesOf(root);
+        const objects = [];
+        for (const [key, value] of Object.entries(root)) {
+            if (key.startsWith(ATTRIBUTE) || key === '#text')
+                continue;
+            if (Array.isArray(value)) {
+                for (const item of value)
+                    collectObjects(item, key, objects, 1);
+            }
+            else {
+                collectObjects(value, key, objects, 1);
+            }
+        }
+        const name = attributes.name ?? attributes.Name ?? fallbackName;
+        return { file, name, objects };
+    }
+    catch (error) {
+        return { file, name: fallbackName, objects: [], parseError: error instanceof Error ? error.message : String(error) };
+    }
+}
+/** List one directory through the provider, or Node when the provider cannot list. */
+async function listDirectory(fs, path, signal) {
+    if (fs.listDir !== undefined)
+        return await fs.listDir(path, signal);
+    const entries = await readdir(path, { withFileTypes: true });
+    return entries.map(entry => ({ name: entry.name, type: entry.isDirectory() ? 'directory' : 'file' }));
+}
+/** Walk the export folder, calling `visit` for every regular file. */
+async function walk(fs, root, relative, signal, visit, budget) {
+    signal?.throwIfAborted();
+    const path = relative === '' ? root : `${root.replace(/[\\/]$/u, '')}/${relative}`;
+    let entries;
+    try {
+        entries = await listDirectory(fs, path, signal);
+    }
+    catch (error) {
+        throw new EngineeringError('VIEW_UNREADABLE', `Cannot list ${path}: ${error instanceof Error ? error.message : String(error)}`, 'Pass an existing export folder the session can read.');
+    }
+    for (const entry of [...entries].sort((left, right) => left.name.localeCompare(right.name))) {
+        signal?.throwIfAborted();
+        const child = relative === '' ? entry.name : `${relative}/${entry.name}`;
+        if (entry.type === 'directory') {
+            await walk(fs, root, child, signal, visit, budget);
+            continue;
+        }
+        if (!/\.(xml|csv)$/iu.test(entry.name))
+            continue;
+        budget.count += 1;
+        if (budget.count > budget.max) {
+            throw new EngineeringError('VIEW_TOO_LARGE', `The export has more than ${budget.max} display and tag files.`, 'Point ftview_open at one application export folder, not a whole drive.');
+        }
+        await visit(child, `${root.replace(/[\\/]$/u, '')}/${child}`);
+    }
+}
+/**
+ * Scan one export folder.
+ *
+ * @param fs - Filesystem provider.
+ * @param root - Resolved export folder.
+ * @param signal - Cancellation.
+ * @param maxFiles - Largest number of display/tag files accepted.
+ * @returns The scanned application.
+ */
+export async function scanApplication(fs, root, signal, maxFiles) {
+    const displays = [];
+    const tags = [];
+    const tagFiles = [];
+    const tagErrors = [];
+    const diagnostics = [];
+    const files = [];
+    await walk(fs, root, '', signal, async (file, absolute) => {
+        const bytes = await fs.readBytes(absolute, signal, 32 * 1024 * 1024);
+        const text = decode(bytes);
+        files.push({ file, bytes: bytes.length, sha256: createHash('sha256').update(bytes).digest('hex') });
+        if (/\.csv$/iu.test(file)) {
+            const csv = parseTagCsv(text);
+            if (csv.rows.length === 0 && csv.errors.length > 0) {
+                diagnostics.push(`${file}: ${csv.errors.join(' ')}`);
+                return;
+            }
+            tagFiles.push(file);
+            tags.push(...csv.rows);
+            for (const error of csv.errors)
+                tagErrors.push(`${file}: ${error}`);
+            return;
+        }
+        const display = parseDisplay(file, text);
+        if (display.parseError !== undefined) {
+            diagnostics.push(`${file}: ${display.parseError}`);
+            return;
+        }
+        displays.push(display);
+    }, { count: 0, max: maxFiles });
+    const name = root.replace(/[\\/]$/u, '').split(/[\\/]/u).pop() ?? root;
+    return { root, name, displays, tags, tagFiles, tagErrors, diagnostics, files };
+}

package/vendor/ftview/lib/session.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Open ME export folders for one chat.
+ *
+ * A folder is scanned once when opened; later calls read the same application
+ * model. Handles belong to the calling chat and are bounded, so an abandoned
+ * conversation does not retain export trees.
+ *
+ * @module dsh-engineering-ftview/session
+ */
+import { type ExecContext, type FsService } from './core.ts';
+import { type Application } from './model.ts';
+/** One opened export folder. */
+export interface OpenView {
+    readonly id: string;
+    readonly app: Application;
+}
+/** The scanned export store, keyed by chat. */
+export declare class ViewSession {
+    readonly fs: FsService;
+    private readonly maxFiles;
+    private readonly maxViews;
+    private readonly chats;
+    private readonly detached;
+    /**
+     * @param fs - Filesystem provider.
+     * @param maxFiles - Most display and tag files one open may scan.
+     * @param maxViews - Most export folders one chat retains.
+     */
+    constructor(fs: FsService, maxFiles: number, maxViews?: number);
+    /**
+     * Resolve, check and scan one export folder for the calling chat.
+     *
+     * @param requestedRoot - Folder as the caller supplied it.
+     * @param exec - Calling context: cancellation, workspace and chat identity.
+     * @returns The retained view.
+     */
+    open(requestedRoot: string, exec?: ExecContext): Promise<OpenView>;
+    /**
+     * Resolve the view a call applies to.
+     *
+     * @param viewId - Explicit handle, or undefined to use the chat's only view.
+     * @param exec - Calling context.
+     * @returns The open view.
+     */
+    require(viewId: string | undefined, exec?: ExecContext): OpenView;
+    /** The view map for one calling chat. */
+    private viewsOf;
+}

package/vendor/ftview/lib/session.js

@@ -0,0 +1,98 @@
+/**
+ * Open ME export folders for one chat.
+ *
+ * A folder is scanned once when opened; later calls read the same application
+ * model. Handles belong to the calling chat and are bounded, so an abandoned
+ * conversation does not retain export trees.
+ *
+ * @module dsh-engineering-ftview/session
+ */
+import { randomUUID } from 'node:crypto';
+import { EngineeringError } from "./core.js";
+import { scanApplication } from "./model.js";
+/** The scanned export store, keyed by chat. */
+export class ViewSession {
+    fs;
+    maxFiles;
+    maxViews;
+    chats = new WeakMap();
+    detached = new Map();
+    /**
+     * @param fs - Filesystem provider.
+     * @param maxFiles - Most display and tag files one open may scan.
+     * @param maxViews - Most export folders one chat retains.
+     */
+    constructor(fs, maxFiles, maxViews = 2) {
+        this.fs = fs;
+        this.maxFiles = maxFiles;
+        this.maxViews = maxViews;
+    }
+    /**
+     * Resolve, check and scan one export folder for the calling chat.
+     *
+     * @param requestedRoot - Folder as the caller supplied it.
+     * @param exec - Calling context: cancellation, workspace and chat identity.
+     * @returns The retained view.
+     */
+    async open(requestedRoot, exec) {
+        const root = await this.fs.resolve(requestedRoot, {
+            ...(exec?.cwd === undefined ? {} : { cwd: exec.cwd }),
+            ...(exec?.signal === undefined ? {} : { signal: exec.signal }),
+        });
+        const info = await this.fs.stat(root, exec?.signal);
+        if (info === undefined) {
+            throw new EngineeringError('VIEW_NOT_FOUND', `No export folder exists at ${requestedRoot}.`, 'Pass an absolute path or a path inside this workspace, for example "C:/Projects/Line/ME Export".');
+        }
+        if (info.type !== 'directory') {
+            throw new EngineeringError('INVALID_VIEW', `${requestedRoot} is not a folder.`, 'Pass the export folder that contains the display XML files and the tag CSV.');
+        }
+        const app = await scanApplication(this.fs, root, exec?.signal, this.maxFiles);
+        const view = { id: randomUUID(), app };
+        const views = this.viewsOf(exec);
+        views.set(view.id, view);
+        while (views.size > this.maxViews) {
+            const oldest = views.keys().next().value;
+            if (oldest !== undefined)
+                views.delete(oldest);
+        }
+        return view;
+    }
+    /**
+     * Resolve the view a call applies to.
+     *
+     * @param viewId - Explicit handle, or undefined to use the chat's only view.
+     * @param exec - Calling context.
+     * @returns The open view.
+     */
+    require(viewId, exec) {
+        const views = this.viewsOf(exec);
+        const ids = [...views.keys()];
+        if (viewId === undefined || viewId === '') {
+            const only = ids[0];
+            if (only === undefined) {
+                throw new EngineeringError('NO_VIEW', 'No ME export is open in this chat.', 'Call ftview_open with the export folder first.');
+            }
+            if (ids.length > 1) {
+                throw new EngineeringError('AMBIGUOUS_VIEW', `${ids.length} ME exports are open in this chat, so view_id is required.`, `Pass one of this chat's view ids: ${ids.join(', ')}.`, ids);
+            }
+            return views.get(only);
+        }
+        const view = views.get(viewId);
+        if (view === undefined) {
+            throw new EngineeringError('UNKNOWN_VIEW', `No ME export is open with view_id ${JSON.stringify(viewId)} in this chat.`, ids.length === 0 ? 'Call ftview_open with the export folder first.' : `Pass one of this chat's view ids: ${ids.join(', ')}.`, ids);
+        }
+        return view;
+    }
+    /** The view map for one calling chat. */
+    viewsOf(exec) {
+        const chat = exec?.chat;
+        if (chat === undefined)
+            return this.detached;
+        const existing = this.chats.get(chat);
+        if (existing !== undefined)
+            return existing;
+        const created = new Map();
+        this.chats.set(chat, created);
+        return created;
+    }
+}

package/vendor/ftview/lib/skill.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The guidance half of the FTView port.
+ *
+ * Registers the `factorytalk-view` skill from SKILL.md. It is a separate loader
+ * entry, so a profile can run the tools without the guidance or the guidance
+ * without the tools.
+ *
+ * @module dsh-engineering-ftview/skill
+ */
+/** Plugin name in a composition. */
+export declare const name = "ftview-read-skill";
+/** Services this plugin cannot register without. */
+export declare const inject: readonly ["skills"];
+/** The plugin context this module needs. */
+export interface SkillContext {
+    get(name: string): unknown;
+}
+/** Registration metadata, kept here so a test can assert it without the file. */
+export declare const SKILL: {
+    readonly name: "factorytalk-view";
+    readonly description: "Design and support FactoryTalk View ME and PanelView Plus applications from documented text exports: displays, HMI tags, structural checks and export comparison.";
+    readonly whenToUse: "Use when the user asks about FactoryTalk View ME, PanelView Plus, ME display exports, HMI tags, or comparing ME exports. Route FactoryTalk View SE and Optix to their own surfaces.";
+};
+/**
+ * Register the FactoryTalk View skill.
+ *
+ * @param ctx - Plugin context whose skill registry receives the registration.
+ */
+export declare function apply(ctx: SkillContext): void;

package/vendor/ftview/lib/skill.js

@@ -0,0 +1,43 @@
+/**
+ * The guidance half of the FTView port.
+ *
+ * Registers the `factorytalk-view` skill from SKILL.md. It is a separate loader
+ * entry, so a profile can run the tools without the guidance or the guidance
+ * without the tools.
+ *
+ * @module dsh-engineering-ftview/skill
+ */
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+/** Plugin name in a composition. */
+export const name = 'ftview-read-skill';
+/** Services this plugin cannot register without. */
+export const inject = ['skills'];
+/** Registration metadata, kept here so a test can assert it without the file. */
+export const SKILL = {
+    name: 'factorytalk-view',
+    description: 'Design and support FactoryTalk View ME and PanelView Plus applications from documented text exports: displays, HMI tags, structural checks and export comparison.',
+    whenToUse: 'Use when the user asks about FactoryTalk View ME, PanelView Plus, ME display exports, HMI tags, or comparing ME exports. Route FactoryTalk View SE and Optix to their own surfaces.',
+};
+/**
+ * Register the FactoryTalk View skill.
+ *
+ * @param ctx - Plugin context whose skill registry receives the registration.
+ */
+export function apply(ctx) {
+    const skills = ctx.get('skills');
+    if (skills === undefined || typeof skills.register !== 'function') {
+        throw new Error('ftview-read-skill: the skills service is unavailable, so the factorytalk-view guidance cannot register');
+    }
+    const skillPath = fileURLToPath(new URL('../SKILL.md', import.meta.url));
+    const raw = readFileSync(skillPath, 'utf8');
+    const content = raw.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n/u, '');
+    skills.register({
+        ...SKILL,
+        content,
+        path: skillPath,
+        source: 'custom',
+        provider: '@aryacode/dsh-engineering-ftview',
+        invocation: { modelInvocable: true, userInvocable: true },
+    });
+}

package/vendor/ftview/lib/studio/discover.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Bounded discovery of FactoryTalk View Studio ME tooling.
+ *
+ * Reads directories through the filesystem provider, never executes anything.
+ * A missing install is reported as such; absence of a utility is not an error,
+ * because the manual Studio workflow does not need it.
+ *
+ * @module dsh-engineering-ftview/studio/discover
+ */
+import type { FsService } from '../core.ts';
+/** One executable the discovery found. */
+export interface DiscoveredUtility {
+    readonly path: string;
+    readonly bytes: number;
+    readonly sha256: string;
+}
+/** What the discovery found. */
+export interface StudioDiscovery {
+    readonly searched: readonly string[];
+    readonly products: readonly string[];
+    readonly schemas: readonly string[];
+    readonly utilities: readonly DiscoveredUtility[];
+    readonly help: readonly string[];
+    readonly truncated: boolean;
+}
+/** Known install roots for FactoryTalk View on Windows. */
+export declare const DEFAULT_SEARCH_ROOTS: readonly string[];
+/**
+ * Discover View Studio tooling under the configured roots.
+ *
+ * @param fs - Filesystem provider.
+ * @param roots - Absolute roots to search.
+ * @param signal - Cancellation.
+ * @returns What was found, plus the roots that were searched.
+ */
+export declare function discoverStudio(fs: FsService, roots: readonly string[], signal: AbortSignal | undefined): Promise<StudioDiscovery>;

package/vendor/ftview/lib/studio/discover.js

@@ -0,0 +1,87 @@
+/**
+ * Bounded discovery of FactoryTalk View Studio ME tooling.
+ *
+ * Reads directories through the filesystem provider, never executes anything.
+ * A missing install is reported as such; absence of a utility is not an error,
+ * because the manual Studio workflow does not need it.
+ *
+ * @module dsh-engineering-ftview/studio/discover
+ */
+import { createHash } from 'node:crypto';
+/** Directory depth the discovery walks below each root. */
+const MAX_DEPTH = 4;
+/** Directory entries the discovery visits per root before it stops. */
+const MAX_ENTRIES_PER_ROOT = 4000;
+/** Known install roots for FactoryTalk View on Windows. */
+export const DEFAULT_SEARCH_ROOTS = [
+    'C:/Program Files (x86)/Rockwell Software',
+    'C:/Program Files/Rockwell Software',
+];
+/** Walk one root and collect products, schemas, utilities and help files. */
+async function walkRoot(fs, root, signal, found) {
+    const queue = [{ path: root, depth: 0 }];
+    let visited = 0;
+    while (queue.length > 0) {
+        signal?.throwIfAborted();
+        const current = queue.shift();
+        let entries;
+        try {
+            entries = fs.listDir === undefined ? [] : await fs.listDir(current.path, signal);
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            visited += 1;
+            if (visited > MAX_ENTRIES_PER_ROOT) {
+                found.truncated = true;
+                return;
+            }
+            const path = `${current.path}/${entry.name}`;
+            if (entry.type === 'directory') {
+                if (/FactoryTalk View/i.test(entry.name))
+                    found.products.push(path);
+                if (current.depth < MAX_DEPTH)
+                    queue.push({ path, depth: current.depth + 1 });
+                continue;
+            }
+            if (/^SEAddComponent\.exe$/iu.test(entry.name)) {
+                try {
+                    const bytes = await fs.readBytes(path, signal, 64 * 1024 * 1024);
+                    found.utilities.push({ path, bytes: bytes.length, sha256: createHash('sha256').update(bytes).digest('hex') });
+                }
+                catch {
+                    found.utilities.push({ path, bytes: 0, sha256: '' });
+                }
+                continue;
+            }
+            if (/^Gfx-ME.*\.xsd$/iu.test(entry.name))
+                found.schemas.push(path);
+            if (/\.chm$/iu.test(entry.name))
+                found.help.push(path);
+        }
+    }
+}
+/**
+ * Discover View Studio tooling under the configured roots.
+ *
+ * @param fs - Filesystem provider.
+ * @param roots - Absolute roots to search.
+ * @param signal - Cancellation.
+ * @returns What was found, plus the roots that were searched.
+ */
+export async function discoverStudio(fs, roots, signal) {
+    const found = { products: [], schemas: [], utilities: [], help: [], truncated: false };
+    const searched = [];
+    for (const root of roots) {
+        const resolved = await fs.resolve(root, {
+            ...(signal === undefined ? {} : { signal }),
+        });
+        const info = await fs.stat(resolved, signal);
+        searched.push(resolved);
+        if (info === undefined || info.type !== 'directory')
+            continue;
+        await walkRoot(fs, resolved, signal, found);
+    }
+    return { searched, ...found };
+}

package/vendor/ftview/lib/studio/preflight.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Preflight and handoff for a manual FactoryTalk View Studio import.
+ *
+ * This entry never runs a vendor utility. Preflight reports what a Studio
+ * import would touch and which prerequisites are missing; handoff returns the
+ * ordered manual steps. Automation through `SEAddComponent.exe` is deliberately
+ * absent until it can be validated in a licensed environment.
+ *
+ * @module dsh-engineering-ftview/studio/preflight
+ */
+import type { Application } from '../model.ts';
+import type { StudioDiscovery } from './discover.ts';
+/** The result of checking one change set for Studio. */
+export interface StudioCheck {
+    readonly changed: readonly string[];
+    readonly blockers: readonly string[];
+    readonly warnings: readonly string[];
+    readonly ready: boolean;
+    readonly utility_available: boolean;
+}
+/** One manual step. */
+export interface HandoffStep {
+    readonly step: number;
+    readonly action: string;
+    readonly files?: readonly string[];
+}
+/** The manual plan. */
+export interface HandoffPlan {
+    readonly application: string;
+    readonly changed: readonly string[];
+    readonly steps: readonly HandoffStep[];
+    readonly utility_available: boolean;
+}
+/**
+ * Compare two exports and check whether the changed displays can be imported.
+ *
+ * @param before - The earlier export.
+ * @param after - The edited export.
+ * @param discovery - Studio tooling that was found.
+ * @returns Changed files, blockers, warnings and readiness.
+ */
+export declare function studioPreflight(before: Application, after: Application, discovery: StudioDiscovery): StudioCheck;
+/**
+ * Produce the ordered manual import plan.
+ *
+ * @param before - The earlier export.
+ * @param after - The edited export.
+ * @param discovery - Studio tooling that was found.
+ * @returns The plan.
+ */
+export declare function handoffPlan(before: Application, after: Application, discovery: StudioDiscovery): HandoffPlan;