@aryacode/dsh-engineering 0.8.3 → 0.9.0

package/vendor/ftview/lib/vendor.js

@@ -11,7 +11,7 @@
  * @module dsh-engineering-ftview/vendor
  */
 import { spawn } from 'node:child_process';
-import { existsSync, readdirSync, statSync } from 'node:fs';
+import { copyFileSync, existsSync, mkdirSync, readdirSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 /** CLSID of the ME export server (`MEExport.exe`). */
 export const EXPORT_CLSID = '9d882577-aa92-466b-a749-6d6b5093b623';
@@ -88,13 +88,24 @@ export async function listApplications() {
     }
 }
 /**
- * Export one application's displays and globals into a new folder.
+ * Export one application's displays, globals, alarms and tags into a new folder.
+ *
+ * The export server covers displays, global objects and project settings. The
+ * alarm setup and the tag database live beside the application in the Studio
+ * project store, and `ExportAll` does not copy them, so this function does:
+ * without them a "full" export has no tags to bind and no alarms to review.
+ *
+ * Those two files are snapshots Studio writes when it exports them from their
+ * editors, not live views of the database, so each copy is checked against the
+ * application database's timestamp and a stale one is reported rather than
+ * silently handed over as current.
  *
  * @param application - Application name as listed.
  * @param destination - Folder to create and fill.
- * @returns Files written, relative to the destination.
+ * @param documentsRoot - Public Documents folder, injectable for tests.
+ * @returns Files written and any freshness warnings.
  */
-export async function exportApplication(application, destination) {
+export async function exportApplication(application, destination, documentsRoot) {
     if (existsSync(destination))
         return { error: `A file or folder already exists at ${destination}. Export into a new folder.` };
     const result = await runPowerShell('powershell.exe', EXPORT_SCRIPT, { clsid: EXPORT_CLSID, app: application, dest: destination });
@@ -102,6 +113,7 @@ export async function exportApplication(application, destination) {
         return { error: `Export failed: ${result.stderr.trim() || `exit ${result.code}`}` };
     if (!existsSync(destination))
         return { error: 'The engine reported success but wrote no folder.' };
+    const extras = copyProjectExtras(application, destination, documentsRoot);
     const files = [];
     const walk = (directory, prefix) => {
         for (const entry of readdirSync(directory, { withFileTypes: true })) {
@@ -113,7 +125,85 @@ export async function exportApplication(application, destination) {
         }
     };
     walk(destination, '');
-    return { value: files.sort() };
+    return { value: { files: files.sort(), warnings: extras.warnings } };
+}
+/** The Studio project store that holds one application's alarms and tags. */
+export function projectFolder(application, documentsRoot = join(process.env.PUBLIC ?? 'C:/Users/Public', 'Documents')) {
+    const folder = join(documentsRoot, 'RSView Enterprise/ME/HMI projects', application);
+    return existsSync(folder) ? folder : undefined;
+}
+/** A readable date for one file's timestamp. */
+function modifiedOn(path) {
+    try {
+        return statSync(path).mtime.toISOString().slice(0, 10);
+    }
+    catch {
+        return 'unknown';
+    }
+}
+/** A warning when one copied snapshot predates the application database. */
+function freshness(file, relative, database) {
+    if (database === undefined)
+        return undefined;
+    try {
+        if (statSync(file).mtimeMs + 60_000 >= statSync(database).mtimeMs)
+            return undefined;
+        return `${relative} was written ${modifiedOn(file)}, older than the application database (${modifiedOn(database)}); it may not reflect recent changes. Studio refreshes it on its next full export.`;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Copy the alarm setup and the tag CSV from the project store into an export.
+ *
+ * The file names and layout match what Studio writes when it exports the whole
+ * application (`Alarms/Alarms.xml`, `Tags/<application>.csv`), so a reader
+ * cannot tell this export from a hand-made one.
+ *
+ * @param application - Application name.
+ * @param destination - Export folder that already exists.
+ * @param documentsRoot - Public Documents folder, injectable for tests.
+ * @returns Paths copied and any staleness warnings.
+ */
+export function copyProjectExtras(application, destination, documentsRoot) {
+    const source = projectFolder(application, documentsRoot);
+    if (source === undefined) {
+        return { copied: [], warnings: [`No Studio project folder was found for ${application}, so alarms and tags were not exported.`] };
+    }
+    const database = join(source, `${application}.med`);
+    const copied = [];
+    const warnings = [];
+    const alarms = join(source, 'Alarms.xml');
+    if (existsSync(alarms)) {
+        const target = join(destination, 'Alarms');
+        mkdirSync(target, { recursive: true });
+        copyFileSync(alarms, join(target, 'Alarms.xml'));
+        copied.push('Alarms/Alarms.xml');
+        const warning = freshness(alarms, 'Alarms/Alarms.xml', existsSync(database) ? database : undefined);
+        if (warning !== undefined)
+            warnings.push(warning);
+    }
+    else {
+        warnings.push('No Alarms.xml in the application store, so alarms were not exported. Export alarm setup from Studio once.');
+    }
+    // Studio names the tag file `<application>-Tags.CSV`; match the suffix
+    // case-insensitively because older applications used `.csv`.
+    const entries = readdirSync(source, { withFileTypes: true });
+    const tags = entries.find(entry => entry.isFile() && /-tags\.csv$/iu.test(entry.name));
+    if (tags !== undefined) {
+        const target = join(destination, 'Tags');
+        mkdirSync(target, { recursive: true });
+        copyFileSync(join(source, tags.name), join(target, `${application}.csv`));
+        copied.push(`Tags/${application}.csv`);
+        const warning = freshness(join(source, tags.name), `Tags/${application}.csv`, existsSync(database) ? database : undefined);
+        if (warning !== undefined)
+            warnings.push(warning);
+    }
+    else {
+        warnings.push('No tag CSV in the application store, so tags were not exported. Export the tag database from Studio once.');
+    }
+    return { copied, warnings };
 }
 /**
  * Back one application up to a zip.

package/vendor/l5x/lib/engine/style.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Infer the house style of one L5X project.
+ *
+ * Every number here is counted from the export, and the shape is deliberately
+ * the bundle-wide profile schema (`packages/resources/src/profile.ts`) rather
+ * than an L5X-specific one, so the resources row can validate and store it.
+ * Nothing is inferred from fewer than a handful of samples, and the confidence
+ * field says how much of the project the inference actually saw.
+ *
+ * @module dsh-engineering-l5x/engine/style
+ */
+import type { ProjectSnapshot } from '../session.ts';
+/** One counted value. */
+interface Counted {
+    readonly value: string;
+    readonly count: number;
+}
+/** Evidence for one claim. */
+interface Evidence {
+    readonly file?: string;
+    readonly line?: number;
+    readonly count?: number;
+    readonly note: string;
+}
+/** The profile, structurally compatible with the resources schema. */
+export interface L5xStyleProfile {
+    readonly schema: 1;
+    readonly source: {
+        readonly kind: 'l5x';
+        readonly path: string;
+        readonly sha256: string;
+    };
+    readonly naming: {
+        readonly tags: {
+            readonly prefixes: readonly Counted[];
+            readonly case: string;
+        };
+        readonly routines: {
+            readonly case: string;
+            readonly examples: readonly string[];
+        };
+    };
+    readonly idioms: {
+        readonly sealIn: {
+            readonly count: number;
+            readonly form: string;
+        };
+        readonly latch: {
+            readonly count: number;
+        };
+    };
+    readonly comments: {
+        readonly total: number;
+        readonly commented: number;
+        readonly ratio: number;
+    };
+    readonly evidence: readonly Evidence[];
+    readonly confidence: 'low' | 'medium' | 'high';
+}
+/**
+ * Read the style of one project.
+ *
+ * @param project - Snapshot the session opened.
+ * @returns The profile.
+ */
+export declare function styleProfileOf(project: ProjectSnapshot): L5xStyleProfile;
+export {};

package/vendor/l5x/lib/engine/style.js

@@ -0,0 +1,119 @@
+/**
+ * Infer the house style of one L5X project.
+ *
+ * Every number here is counted from the export, and the shape is deliberately
+ * the bundle-wide profile schema (`packages/resources/src/profile.ts`) rather
+ * than an L5X-specific one, so the resources row can validate and store it.
+ * Nothing is inferred from fewer than a handful of samples, and the confidence
+ * field says how much of the project the inference actually saw.
+ *
+ * @module dsh-engineering-l5x/engine/style
+ */
+/** Classify one identifier's case convention. */
+function caseOf(identifier) {
+    if (/^[A-Z][A-Za-z0-9]*$/u.test(identifier))
+        return 'PascalCase';
+    if (/^[a-z][A-Za-z0-9]*$/u.test(identifier))
+        return 'camelCase';
+    if (/^[A-Za-z0-9]+(?:_[A-Za-z0-9]+)+$/u.test(identifier))
+        return 'snake_case';
+    return 'other';
+}
+/** The most common value in a counter, with its count. */
+function top(counts) {
+    let best;
+    for (const [value, count] of counts) {
+        if (best === undefined || count > best.count)
+            best = { value, count };
+    }
+    return best;
+}
+/**
+ * Read the style of one project.
+ *
+ * @param project - Snapshot the session opened.
+ * @returns The profile.
+ */
+export function styleProfileOf(project) {
+    const document = project.document;
+    const rungs = document.routines
+        .filter(routine => routine.body.type === 'RLL')
+        .flatMap(routine => (routine.body.type === 'RLL' ? routine.body.rungs.map(rung => ({ routine: routine.name, rung })) : []));
+    const identifiers = new Map();
+    const prefixes = new Map();
+    const cases = new Map();
+    let sealIn = 0;
+    let latchInstructions = 0;
+    let commented = 0;
+    const evidence = [];
+    const aoiNames = new Set(document.aois.map(aoi => aoi.name.toUpperCase()));
+    let firstSealInRung;
+    for (const { routine, rung } of rungs) {
+        if (rung.comment !== undefined)
+            commented += 1;
+        const text = rung.text;
+        for (const match of text.matchAll(/[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z0-9_]+)*/gu)) {
+            const whole = match[0];
+            if (aoiNames.has(whole.toUpperCase()))
+                continue;
+            const base = whole.split('.')[0] ?? whole;
+            if (base.length < 5)
+                continue;
+            identifiers.set(base, (identifiers.get(base) ?? 0) + 1);
+            const parts = base.split('_');
+            if (parts.length > 1) {
+                const prefix = parts[0];
+                if (/^[A-Z][A-Za-z]{1,6}$/u.test(prefix) && base.length > prefix.length + 3) {
+                    prefixes.set(prefix, (prefixes.get(prefix) ?? 0) + 1);
+                }
+            }
+            const kind = caseOf(base);
+            if (kind !== 'other')
+                cases.set(kind, (cases.get(kind) ?? 0) + 1);
+        }
+        for (const coil of text.matchAll(/OTE\(([^),]+)\)/gu)) {
+            const target = (coil[1] ?? '').trim();
+            const contact = `XIC(${target})`;
+            const coilIndex = coil.index ?? 0;
+            const contactIndex = text.indexOf(contact);
+            if (contactIndex >= 0 && contactIndex < coilIndex) {
+                sealIn += 1;
+                if (firstSealInRung === undefined)
+                    firstSealInRung = rung.number;
+            }
+        }
+        latchInstructions += (text.match(/OT[LU]\(/gu) ?? []).length;
+    }
+    const total = rungs.length;
+    const dominant = top(prefixes);
+    const dominantCase = top(cases);
+    const prefixShare = dominant === undefined ? 0 : dominant.count / Math.max(1, [...prefixes.values()].reduce((sum, count) => sum + count, 0));
+    const routineCases = new Map();
+    for (const routine of document.routines) {
+        const kind = caseOf(routine.name);
+        if (kind !== 'other')
+            routineCases.set(kind, (routineCases.get(kind) ?? 0) + 1);
+    }
+    const routineCase = top(routineCases);
+    if (dominant !== undefined)
+        evidence.push({ count: dominant.count, note: `tag prefix "${dominant.value}" appears ${dominant.count} time(s)` });
+    if (firstSealInRung !== undefined)
+        evidence.push({ line: firstSealInRung, count: sealIn, note: `seal-in rungs detected from rung ${firstSealInRung}` });
+    evidence.push({ count: total, note: `${total} ladder rung(s) read, ${commented} with a comment` });
+    const confidence = total >= 50 && prefixShare >= 0.5 ? 'high' : total >= 10 ? 'medium' : 'low';
+    return {
+        schema: 1,
+        source: { kind: 'l5x', path: project.path, sha256: project.sha256 },
+        naming: {
+            tags: { prefixes: [...prefixes].sort((left, right) => right[1] - left[1]).slice(0, 6).map(([value, count]) => ({ value, count })), case: dominantCase?.value ?? 'PascalCase' },
+            routines: { case: routineCase?.value ?? 'PascalCase', examples: document.routines.slice(0, 5).map(routine => routine.name) },
+        },
+        idioms: {
+            sealIn: { count: sealIn, form: sealIn > 0 ? 'XIC(seal) in parallel with the start contact, in series with the stop contact' : 'not observed' },
+            latch: { count: latchInstructions },
+        },
+        comments: { total, commented, ratio: total === 0 ? 0 : Number((commented / total).toFixed(2)) },
+        evidence,
+        confidence,
+    };
+}

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

@@ -12,6 +12,7 @@
  * @module dsh-engineering-l5x/session
  */
 import { type L5xDocument } from './model/index.ts';
+import { type L5xStyleProfile } from './engine/style.ts';
 import type { ExecContext } from './core/tool.ts';
 import { L5xError } from './core/errors.ts';
 import type { FsService, FsTarget } from './core/tool.ts';
@@ -93,6 +94,14 @@ export declare class ProjectSession {
      * @returns The open project.
      */
     require(projectId: string | undefined, exec?: ExecContext): Promise<ProjectSnapshot>;
+    /**
+     * Read the house style of one open project.
+     *
+     * @param projectId - Explicit handle, or undefined for the chat's only project.
+     * @param exec - Calling context.
+     * @returns The profile in the shared resources schema.
+     */
+    styleProfile(projectId: string | undefined, exec?: ExecContext): Promise<L5xStyleProfile>;
     /**
      * Resolve one path through the filesystem provider without reading it.
      *

package/vendor/l5x/lib/session.js

@@ -13,6 +13,7 @@
  */
 import { createHash, randomUUID } from 'node:crypto';
 import { L5xParseError, loadL5x } from "./model/index.js";
+import { styleProfileOf } from "./engine/style.js";
 import { L5xError } from "./core/errors.js";
 import { decodeExport } from "./fs.js";
 /** A failure raised by an analysis engine. */
@@ -130,6 +131,16 @@ export class ProjectSession {
         }
         return project;
     }
+    /**
+     * Read the house style of one open project.
+     *
+     * @param projectId - Explicit handle, or undefined for the chat's only project.
+     * @param exec - Calling context.
+     * @returns The profile in the shared resources schema.
+     */
+    async styleProfile(projectId, exec) {
+        return styleProfileOf(await this.require(projectId, exec));
+    }
     /**
      * Resolve one path through the filesystem provider without reading it.
      *

package/vendor/resources/SKILL.md

@@ -0,0 +1,27 @@
+# Engineering standards
+
+Use this skill whenever you write, change or review control code or HMI screens — before you author, not
+after.
+
+## Read first
+
+- `engineering_reference` with no arguments lists the corpus. Search it for the language and the domain
+  you are about to touch (`iec state machine`, `rockwell naming`, `view alarm`, `craft fault`), then read
+  the page. Each page carries rule IDs; cite the ID when you report a finding.
+- When a project or export is open, call `engineering_profile` **before** writing. It reports the naming,
+  idioms and visual conventions the plant already uses, with evidence and a confidence level. Follow the
+  profile where it is confident; where it is low, say so and ask.
+
+## Order of work
+
+1. Read the profile (existing project) or the standard pages (new work).
+2. Author the change with the project's own names and visual language.
+3. `engineering_review` on the draft. Fix findings you agree with; explain the ones you do not.
+4. Then run the product's own validation (`draft_validate`, `ftview_validate`, `mw_compile`).
+
+## Honesty rules
+
+- A profile is evidence, not authority: quote the counts and the source path when you rely on it.
+- A rule ID is this bundle's opinion. Never present it as a standards clause or a certification.
+- Do not reproduce standards text; link the page instead.
+- If the corpus or a profile is unavailable, say which one and continue with the product's own checks.

package/vendor/resources/lib/corpus.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Loading and searching the engineering corpus.
+ *
+ * The corpus is Markdown with front matter; `scripts/gen-resources.mjs` turns it
+ * into `index.json` and `SOURCE.json`. This module reads only those generated
+ * files plus the page bodies, so searching is deterministic and needs no model,
+ * network or tokenizer.
+ *
+ * @module dsh-engineering-resources/corpus
+ */
+/** One page as the index records it. */
+export interface PageRow {
+    readonly id: string;
+    readonly title: string;
+    readonly domain: string;
+    readonly level: string;
+    readonly basis: readonly string[];
+    readonly tags: readonly string[];
+    readonly applies_to: readonly string[];
+    readonly rules: readonly string[];
+    readonly words: number;
+    readonly bytes: number;
+    readonly sha256: string;
+}
+/** The generated index. */
+export interface CorpusIndex {
+    readonly corpus: number;
+    readonly pages: readonly PageRow[];
+}
+/** One hit from a search. */
+export interface CorpusHit {
+    readonly id: string;
+    readonly title: string;
+    readonly domain: string;
+    readonly level: string;
+    readonly rules: readonly string[];
+    readonly score: number;
+}
+/** The corpus in memory, or the reason it is unavailable. */
+export interface Corpus {
+    readonly index: CorpusIndex;
+    readonly digest: string;
+    readonly directory: string;
+}
+/**
+ * Load the index and source pin once per process.
+ *
+ * @returns The corpus.
+ * @throws when the generated files are missing, which means the build did not run.
+ */
+export declare function corpus(): Corpus;
+/**
+ * Read one page body.
+ *
+ * @param id - Page id, as listed by the contents.
+ * @returns Markdown body.
+ */
+export declare function pageBody(id: string): string;
+/**
+ * Rank pages by metadata, then by body text for the remainder.
+ *
+ * @param query - Free text, rule id, tag or page id.
+ * @param limit - Most hits to return.
+ * @param domain - Optional domain filter.
+ * @returns Ranked hits, best first.
+ */
+export declare function search(query: string, limit?: number, domain?: string): readonly CorpusHit[];
+/** Domain order for the contents listing. */
+export declare const DOMAINS: readonly ["iec", "rockwell", "yaskawa", "view", "optix", "craft"];
+/** The contents, grouped by domain, with word counts. */
+export declare function contents(): {
+    domains: readonly string[];
+    pages: readonly {
+        id: string;
+        title: string;
+        domain: string;
+        level: string;
+        words: number;
+    }[];
+};

package/vendor/resources/lib/corpus.js

@@ -0,0 +1,126 @@
+/**
+ * Loading and searching the engineering corpus.
+ *
+ * The corpus is Markdown with front matter; `scripts/gen-resources.mjs` turns it
+ * into `index.json` and `SOURCE.json`. This module reads only those generated
+ * files plus the page bodies, so searching is deterministic and needs no model,
+ * network or tokenizer.
+ *
+ * @module dsh-engineering-resources/corpus
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+/** Where the corpus lives, relative to the built module. */
+const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
+let cached;
+/**
+ * Load the index and source pin once per process.
+ *
+ * @returns The corpus.
+ * @throws when the generated files are missing, which means the build did not run.
+ */
+export function corpus() {
+    if (cached !== undefined)
+        return cached;
+    const indexPath = join(ROOT, 'index.json');
+    const sourcePath = join(ROOT, 'SOURCE.json');
+    if (!existsSync(indexPath) || !existsSync(sourcePath)) {
+        throw Object.assign(new Error('The engineering corpus is missing; run `pnpm resources:build` before packing.'), { code: 'RESOURCES_MISSING' });
+    }
+    const index = JSON.parse(readFileSync(indexPath, 'utf8'));
+    const source = JSON.parse(readFileSync(sourcePath, 'utf8'));
+    if (!Array.isArray(index.pages) || index.pages.length === 0) {
+        throw Object.assign(new Error('The engineering corpus is empty; run `pnpm resources:build`.'), { code: 'RESOURCES_MISSING' });
+    }
+    cached = { index, digest: source.digest, directory: ROOT };
+    return cached;
+}
+/**
+ * Read one page body.
+ *
+ * @param id - Page id, as listed by the contents.
+ * @returns Markdown body.
+ */
+export function pageBody(id) {
+    const { index } = corpus();
+    const row = index.pages.find(page => page.id === id);
+    if (row === undefined) {
+        throw Object.assign(new Error(`No resource page named "${id}".`), { code: 'COMPONENT_NOT_FOUND' });
+    }
+    const path = join(ROOT, 'corpus', row.domain, `${row.id}.md`);
+    if (!existsSync(path)) {
+        throw Object.assign(new Error(`The page file for "${id}" is missing from the corpus.`), { code: 'RESOURCES_MISSING' });
+    }
+    // Strip the front matter: the index already carries it, and repeating it in
+    // the answer spends tokens for nothing.
+    return readFileSync(path, 'utf8').replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n/u, '');
+}
+/** Score one page against a query. Higher is better; zero is no hit. */
+function scoreOf(row, needle) {
+    if (row.id === needle)
+        return 100;
+    if (row.rules.some(rule => rule.toLowerCase() === needle))
+        return 95;
+    if (row.title.toLowerCase() === needle)
+        return 90;
+    if (row.tags.some(tag => tag.toLowerCase() === needle))
+        return 80;
+    if (row.id.includes(needle))
+        return 60;
+    if (row.title.toLowerCase().includes(needle))
+        return 55;
+    if (row.tags.some(tag => tag.toLowerCase().includes(needle)))
+        return 45;
+    if (row.rules.some(rule => rule.toLowerCase().startsWith(needle)))
+        return 40;
+    if (row.domain === needle)
+        return 35;
+    return 0;
+}
+/**
+ * Rank pages by metadata, then by body text for the remainder.
+ *
+ * @param query - Free text, rule id, tag or page id.
+ * @param limit - Most hits to return.
+ * @param domain - Optional domain filter.
+ * @returns Ranked hits, best first.
+ */
+export function search(query, limit = 8, domain) {
+    const { index } = corpus();
+    const needle = query.trim().toLowerCase();
+    const tokens = needle.split(/\s+/u).filter(Boolean);
+    const pool = domain === undefined ? index.pages : index.pages.filter(page => page.domain === domain);
+    const scored = pool
+        .map(row => ({ row, score: tokens.reduce((sum, token) => sum + scoreOf(row, token), 0) }))
+        .filter(hit => hit.score > 0);
+    if (scored.length < limit) {
+        const seen = new Set(scored.map(hit => hit.row.id));
+        for (const row of pool) {
+            if (seen.has(row.id))
+                continue;
+            try {
+                const body = pageBody(row.id).toLowerCase();
+                if (tokens.every(token => body.includes(token)))
+                    scored.push({ row, score: 20 });
+            }
+            catch {
+                // A missing page file is reported when it is read, not during ranking.
+            }
+        }
+    }
+    return scored
+        .sort((left, right) => right.score - left.score || left.row.id.localeCompare(right.row.id))
+        .slice(0, Math.min(Math.max(limit, 1), 20))
+        .map(hit => ({ id: hit.row.id, title: hit.row.title, domain: hit.row.domain, level: hit.row.level, rules: hit.row.rules, score: hit.score }));
+}
+/** Domain order for the contents listing. */
+export const DOMAINS = ['iec', 'rockwell', 'yaskawa', 'view', 'optix', 'craft'];
+/** The contents, grouped by domain, with word counts. */
+export function contents() {
+    const { index } = corpus();
+    return {
+        domains: DOMAINS.filter(domain => index.pages.some(page => page.domain === domain)),
+        pages: index.pages.map(page => ({ id: page.id, title: page.title, domain: page.domain, level: page.level, words: page.words })),
+    };
+}

package/vendor/resources/lib/index.d.ts

@@ -0,0 +1,55 @@
+/**
+ * The engineering resources row: a local standards corpus, a house-style profile
+ * and the `engineering-standards` skill that tells a model to read both before
+ * authoring.
+ *
+ * The corpus is generated data (`index.json`, `SOURCE.json`) over authored
+ * Markdown; the profile is produced by whichever product package has a project
+ * open. This entry only wires them to the tool registry and, when the host offers
+ * it, to the skills service.
+ *
+ * @module dsh-engineering-resources
+ */
+import type { StyleProfile } from './profile.ts';
+/** Plugin name in a composition. */
+export declare const name = "engineering-resources";
+/** The tools need the registry; the skill is registered when the host offers it. */
+export declare const inject: string[];
+/** The service name a generation tool can inject to read a profile by handle. */
+export declare const PROFILES_SERVICE = "engineeringProfiles";
+/** The skill metadata, kept here so a test can assert it without the file. */
+export declare const SKILL: {
+    name: string;
+    description: string;
+    whenToUse: string;
+};
+/** Configuration for the row. */
+export interface Config {
+    /** Whether the reference and profile tools are registered. Defaults to true. */
+    reference?: boolean;
+}
+/** The service exposed to other rows. */
+export interface ProfilesService {
+    /** The profile for one handle, when it is still in memory. */
+    get(id: string): StyleProfile | undefined;
+}
+/**
+ * Register the resource tools and the standards skill.
+ *
+ * @param ctx - Plugin context with the tool registry and optional services.
+ * @param config - Row configuration.
+ */
+export declare function apply(ctx: {
+    tools: {
+        register(definition: unknown): void;
+    };
+    get?: (name: string) => unknown;
+    provide?: (name: string, value: unknown) => void;
+    logger?: {
+        warn?(message: string): void;
+    };
+}, config?: Config): void;
+export { getProfile } from './store.ts';
+export { validateProfile, profileId } from './profile.ts';
+export type { StyleProfile } from './profile.ts';
+export { resourceTools, referenceTool, profileTool } from './tools.ts';