@aryacode/dsh-engineering 0.0.0-stage → 0.4.0

package/vendor/mwi/legacy/pou-package.js

@@ -0,0 +1,66 @@
+import {isDeepStrictEqual as same} from 'node:util';
+const sourceKeys=['pous','tasks','globals','program_sources','translation_files'];
+const identical=(before,after)=>sourceKeys.every(k=>same(before[k],after[k]));
+const exact=(rows,name)=>rows.find(p=>p.name===name);
+const prefix=(file,name)=>file.replaceAll('\\','/').toLowerCase().startsWith('poe/'+name.toLowerCase()+'/');
+export function alignSavedNative(saved,native){
+ const fields=['name','type','section','group','address','initial_value','description'];
+ const projectRows=rows=>rows.map(v=>Object.fromEntries(fields.map(k=>[k,k==='description'?(v[k]?.trim()||null):v[k]??null]))).sort((a,b)=>a.name.localeCompare(b.name));
+ // COM omits worksheet comments on externals. Verify those through the exact
+ // saved translation/body baseline, while preserving raw native rows separately.
+ const declarationRows=rows=>projectRows(rows.map(v=>v.section==='VAR_EXTERNAL'?{...v,description:null}:v));
+ if(saved.pous.length!==native.structure.pous.length||!same(projectRows(saved.globals),projectRows(native.declarations.globals.variables)))throw Error('Saved/native package inventories or globals disagree');
+ for(const pou of saved.pous){
+  const meta=exact(native.structure.pous,pou.name),declarations=native.declarations['pou:'+pou.name];
+  if(!meta||meta.type!==pou.type||meta.language!==({IL:1,ST:2,FBD:3,LD:4}[pou.language])||!declarations||!same(declarationRows(pou.variables),declarationRows(declarations.variables)))throw Error('Saved/native POU declaration identity disagrees: '+pou.name);
+ }
+ const tasks=rows=>[...rows].sort((a,b)=>a.name.localeCompare(b.name)).map(({name,kind,instances})=>({name,kind,instances}));
+ if(!same(tasks(saved.tasks),tasks(native.structure.tasks)))throw Error('Saved/native task inventories disagree');
+}
+
+export async function exportPouPackage(args,deps){
+ if(args.baseline_saved!==true)throw Error('Reconcile/save edits before native export');
+ if(!/^[A-Za-z_][A-Za-z_0-9]{0,29}$/.test(args.pou??''))throw Error('Exact POU name required');
+ if((await deps.status()).is_modified!==false)throw Error('Unsaved or unknown native baseline');
+ const saved=await deps.saved(),native=await deps.snapshot(),pou=exact(saved.pous,args.pou),meta=exact(native.structure.pous,args.pou);
+ alignSavedNative(saved,native);
+ if(!pou||!meta||meta.read_only||!['ST','LD','FBD'].includes(pou.language))throw Error('Exact writable supported POU required');
+ const result=await deps.mutate({operation:'export',pou:args.pou,before_state:native,before_files:saved.file_hashes});
+ const after=await deps.saved(),afterNative=await deps.snapshot(),status=await deps.status();
+ if(result.return_code!==0||status.is_modified!==false||!identical(saved,after)||!same(native,afterNative))throw Error('Native export or complete source/declaration preservation unverified');
+ const manifest=await deps.manifest();
+ if(!manifest.length||!manifest.some(f=>f.path.toLowerCase()==='pou.tre')||!manifest.some(f=>f.path.toLowerCase()===args.pou.toLowerCase()+'/src.st1'))throw Error('Native package inventory incomplete');
+ return {saved,native,pou,meta,manifest,result};
+}
+
+export async function importPouPackage(args,receipt,deps){
+ if(args.baseline_saved!==true||args.dependencies_reviewed!==true)throw Error('Saved baseline and dependency review required');
+ if(receipt.used)throw Error('Package import was already attempted; inspect retained evidence');
+ if((await deps.status()).is_modified!==false)throw Error('Unsaved or unknown native baseline');
+ const before=await deps.saved(),native=await deps.snapshot(),name=receipt.pou.name;
+ alignSavedNative(before,native);
+ if(before.pous.some(p=>p.name.toLowerCase()===name.toLowerCase())||native.structure.pous.some(p=>p.name.toLowerCase()===name.toLowerCase()))throw Error('POU name already exists; package import never overwrites');
+ if(!same(receipt.manifest,await deps.manifest()))throw Error('Native package changed since export');
+ if(!same(native.libraries,receipt.native.libraries))throw Error('Native library bindings changed; inspect dependencies');
+ for(const v of receipt.pou.variables.filter(v=>v.section==='VAR_EXTERNAL')){
+  if(!before.globals.some(g=>g.name.toUpperCase()===v.name.toUpperCase()&&g.type.toUpperCase()===v.type.toUpperCase()))throw Error('Missing/mismatched external: '+v.name);
+ }
+ await deps.consume();
+ const result=await deps.mutate({operation:'import',pou:name,before_state:native,before_files:before.file_hashes,package_manifest:receipt.manifest});
+ const after=await deps.saved(),afterNative=await deps.snapshot(),status=await deps.status(),errors=[];
+ if(result.return_code!==0||result.saved!==true||status.is_modified!==false)errors.push('Native import/save not proven');
+ if(!same(receipt.pou,exact(after.pous,name)))errors.push('Imported body/declarations differ from native export');
+ if(!same([...before.pous,receipt.pou].sort((a,b)=>a.name<b.name?-1:a.name>b.name?1:0),after.pous))errors.push('Saved POU inventory/collateral differs from plan');
+ for(const key of ['tasks','globals'])if(!same(before[key],after[key]))errors.push('Unrelated '+key+' changed');
+ for(const key of ['program_sources','translation_files']){
+  for(const file of new Set([...Object.keys(before[key]),...Object.keys(after[key])])){
+   const expected=prefix(file,name)?receipt.saved[key][file]:before[key][file];
+   if(!same(expected,after[key][file]))errors.push('Source/translation differs: '+file);
+  }
+  for(const file of Object.keys(receipt.saved[key]).filter(f=>prefix(f,name)))if(!same(receipt.saved[key][file],after[key][file]))errors.push('Imported source missing/different: '+file);
+ }
+ const expectedNative=structuredClone(native);expectedNative.structure.pous.push(receipt.meta);
+ expectedNative.declarations['pou:'+name]=receipt.native.declarations['pou:'+name];
+ if(!same(expectedNative,afterNative))errors.push('Complete native metadata/groups/declaration flags differ from plan');
+ return {accepted:!errors.length,errors,result,before,after,native_before:native,native_after:afterNative};
+}

package/vendor/mwi/lib/core/bridge.d.ts

@@ -0,0 +1,71 @@
+/**
+ * The typed boundary to the 32-bit COM bridge.
+ *
+ * The bridge is implementation: it owns the PowerShell process and the vendor
+ * automation components, while the tools speak this request/response contract.
+ * Phase 0 defines the contract; the PowerShell transport lands with the session
+ * row.
+ *
+ * @module dsh-engineering-mwi/core/bridge
+ */
+/** One operation the bridge understands. */
+export interface BridgeRequest {
+    /** Operation name, for example `ide-status` or `pou-read`. */
+    readonly operation: string;
+    /** Operation arguments; the bridge validates them. */
+    readonly arguments: Readonly<Record<string, unknown>>;
+}
+/** The bridge's answer. */
+export interface BridgeResponse {
+    /** Whether the operation completed. */
+    readonly ok: boolean;
+    /** Operation result when `ok` is true. */
+    readonly result?: unknown;
+    /** Failure when `ok` is false. */
+    readonly error?: {
+        readonly code: string;
+        readonly message: string;
+        readonly details?: string;
+    };
+}
+/** The process boundary the client is built over. */
+export interface BridgeTransport {
+    /**
+     * Send one request and read one response.
+     *
+     * @param request - Operation and arguments.
+     * @param timeoutMs - Hard operation budget.
+     * @param signal - Cancellation owned by the caller.
+     * @returns The bridge's answer.
+     */
+    send(request: BridgeRequest, timeoutMs: number, signal?: AbortSignal): Promise<BridgeResponse>;
+}
+/** Default operation budget; IDE compile operations are allowed to override it. */
+export declare const DEFAULT_TIMEOUT_MS = 120000;
+/** The typed client the tools call. */
+export declare class Bridge {
+    private readonly transport;
+    private readonly timeoutMs;
+    /**
+     * @param transport - Process boundary that speaks to the PowerShell bridge.
+     * @param timeoutMs - Default operation budget.
+     */
+    constructor(transport: BridgeTransport, timeoutMs?: number);
+    /**
+     * Run one bridge operation.
+     *
+     * @param operation - Operation name.
+     * @param args - Operation arguments.
+     * @param timeoutMs - Operation budget; defaults to the client budget.
+     * @param signal - Cancellation owned by the caller.
+     * @returns The operation result.
+     * @throws MwiError when the operation fails or the bridge refuses it.
+     */
+    run(operation: string, args?: Readonly<Record<string, unknown>>, timeoutMs?: number, signal?: AbortSignal): Promise<unknown>;
+}
+/**
+ * Refuse on a host that cannot run the MotionWorks IDE.
+ *
+ * @param platform - Host platform; defaults to the running process.
+ */
+export declare function assertSupportedPlatform(platform?: NodeJS.Platform): void;

package/vendor/mwi/lib/core/bridge.js

@@ -0,0 +1,53 @@
+/**
+ * The typed boundary to the 32-bit COM bridge.
+ *
+ * The bridge is implementation: it owns the PowerShell process and the vendor
+ * automation components, while the tools speak this request/response contract.
+ * Phase 0 defines the contract; the PowerShell transport lands with the session
+ * row.
+ *
+ * @module dsh-engineering-mwi/core/bridge
+ */
+import { MwiError } from "./errors.js";
+/** Default operation budget; IDE compile operations are allowed to override it. */
+export const DEFAULT_TIMEOUT_MS = 120_000;
+/** The typed client the tools call. */
+export class Bridge {
+    transport;
+    timeoutMs;
+    /**
+     * @param transport - Process boundary that speaks to the PowerShell bridge.
+     * @param timeoutMs - Default operation budget.
+     */
+    constructor(transport, timeoutMs = DEFAULT_TIMEOUT_MS) {
+        this.transport = transport;
+        this.timeoutMs = timeoutMs;
+    }
+    /**
+     * Run one bridge operation.
+     *
+     * @param operation - Operation name.
+     * @param args - Operation arguments.
+     * @param timeoutMs - Operation budget; defaults to the client budget.
+     * @param signal - Cancellation owned by the caller.
+     * @returns The operation result.
+     * @throws MwiError when the operation fails or the bridge refuses it.
+     */
+    async run(operation, args = {}, timeoutMs = this.timeoutMs, signal) {
+        const response = await this.transport.send({ operation, arguments: args }, timeoutMs, signal);
+        if (!response.ok) {
+            throw new MwiError(response.error?.code ?? 'BRIDGE_FAILED', response.error?.message ?? `The MotionWorks bridge refused ${operation}.`, 'Call mw_ide_status, resolve any modal dialog, then retry. If it repeats, restart the IDE and the bridge.');
+        }
+        return response.result;
+    }
+}
+/**
+ * Refuse on a host that cannot run the MotionWorks IDE.
+ *
+ * @param platform - Host platform; defaults to the running process.
+ */
+export function assertSupportedPlatform(platform = process.platform) {
+    if (platform !== 'win32') {
+        throw new MwiError('PLATFORM_UNSUPPORTED', `MotionWorks IEC 3 Pro is a Windows application; this host is ${platform}.`, 'Enable the MotionWorks rows only on a Windows host with the IDE installed.');
+    }
+}

package/vendor/mwi/lib/core/code-engine.d.ts

@@ -0,0 +1,47 @@
+/**
+ * The Python code engine.
+ *
+ * The engine owns the saved-project work the COM bridge does not: binding a
+ * staged `.mwt` wrapper to its new directory, reading saved declarations and
+ * validating native containers. It is stdlib-only and speaks a file protocol:
+ * one request JSON in, one response JSON out.
+ *
+ * @module dsh-engineering-mwi/core/code-engine
+ */
+/** Where the engine lives and which workspace it serves. */
+export interface CodeEngineOptions {
+    /** Absolute workspace root. */
+    readonly workspace: string;
+    /** The only stage root the engine accepts. */
+    readonly stageRoot: string;
+    /** Directory holding `mw_code.py` and `engine/`; defaults to the package's `code/`. */
+    readonly codeDir: string;
+    /** Python interpreter; defaults to MW_PYTHON, the Arya interpreter, then `python`. */
+    readonly python?: string;
+}
+/** One engine response after a successful call. */
+export type EngineResult = Readonly<Record<string, unknown>>;
+/** Resolve the first usable Python 3 interpreter. */
+export declare function findPython(): string;
+/** The typed engine client. */
+export declare class CodeEngine {
+    private readonly options;
+    private readonly python;
+    /**
+     * @param options - Engine location and workspace authorization.
+     */
+    constructor(options: CodeEngineOptions);
+    /**
+     * Run one engine verb.
+     *
+     * @param verb - Engine verb, for example `bind_mwt`.
+     * @param request - Verb arguments.
+     * @param timeoutMs - Hard budget; the engine writes a response file.
+     * @param signal - Cancellation owned by the caller.
+     * @returns The response body after `ok`.
+     * @throws MwiError when the engine refuses or is unavailable.
+     */
+    run(verb: string, request: Readonly<Record<string, unknown>>, timeoutMs?: number, signal?: AbortSignal): Promise<EngineResult>;
+    /** Read the response file, tolerating a partial write. */
+    private readResponse;
+}

package/vendor/mwi/lib/core/code-engine.js

@@ -0,0 +1,109 @@
+/**
+ * The Python code engine.
+ *
+ * The engine owns the saved-project work the COM bridge does not: binding a
+ * staged `.mwt` wrapper to its new directory, reading saved declarations and
+ * validating native containers. It is stdlib-only and speaks a file protocol:
+ * one request JSON in, one response JSON out.
+ *
+ * @module dsh-engineering-mwi/core/code-engine
+ */
+import { spawn } from 'node:child_process';
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { MwiError } from "./errors.js";
+const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+/** Resolve the first usable Python 3 interpreter. */
+export function findPython() {
+    if (process.env.MW_PYTHON)
+        return process.env.MW_PYTHON;
+    const candidates = [
+        join(process.env.LOCALAPPDATA ?? '', 'Programs', 'AryaCode', 'resources', 'runtime', 'primary-runtime', 'dependencies', 'python', 'python.exe'),
+        join(process.env.USERPROFILE ?? '', '.cache', 'codex-runtimes', 'codex-primary-runtime', 'dependencies', 'python', 'python.exe'),
+    ];
+    for (const candidate of candidates) {
+        if (candidate.length > 0 && existsSync(candidate))
+            return candidate;
+    }
+    return 'python';
+}
+/** The typed engine client. */
+export class CodeEngine {
+    options;
+    python;
+    /**
+     * @param options - Engine location and workspace authorization.
+     */
+    constructor(options) {
+        this.options = options;
+        this.python = options.python ?? findPython();
+    }
+    /**
+     * Run one engine verb.
+     *
+     * @param verb - Engine verb, for example `bind_mwt`.
+     * @param request - Verb arguments.
+     * @param timeoutMs - Hard budget; the engine writes a response file.
+     * @param signal - Cancellation owned by the caller.
+     * @returns The response body after `ok`.
+     * @throws MwiError when the engine refuses or is unavailable.
+     */
+    async run(verb, request, timeoutMs = 180_000, signal) {
+        const helper = join(this.options.codeDir, 'mw_code.py');
+        if (!existsSync(helper)) {
+            throw new MwiError('ENGINE_MISSING', `The MotionWorks code engine is missing at ${helper}.`, 'Reinstall the bundle; the package ships code/mw_code.py.');
+        }
+        const ipc = mkdtempSync(join(tmpdir(), 'mwi-engine-'));
+        const requestPath = join(ipc, 'req.json');
+        const responsePath = join(ipc, 'res.json');
+        try {
+            writeFileSync(requestPath, JSON.stringify(request), 'utf8');
+            const child = spawn(this.python, [helper, verb, requestPath, responsePath], {
+                windowsHide: true,
+                stdio: 'ignore',
+                env: {
+                    ...process.env,
+                    MW_SRC: join(this.options.codeDir, 'engine'),
+                    PYTHONIOENCODING: 'utf-8',
+                    MOTIONWORKS_MCP_BACKUP_DIR: join(this.options.workspace, '.motionworks', 'backups'),
+                    MOTIONWORKS_MCP_ROOT: this.options.stageRoot,
+                    MOTIONWORKS_MCP_CLOSE_IDE: '0',
+                    MOTIONWORKS_MCP_WORKSPACE: this.options.workspace,
+                    MOTIONWORKS_MCP_STAGE: this.options.stageRoot,
+                },
+            });
+            const failure = new Promise((_resolve, reject) => {
+                child.once('error', error => reject(new MwiError('PYTHON_UNAVAILABLE', `Cannot start the MotionWorks code engine with ${this.python}: ${error.message}`, 'Set MW_PYTHON to a Python 3 interpreter, then retry.')));
+            });
+            const deadline = Date.now() + timeoutMs;
+            while (Date.now() < deadline) {
+                if (signal?.aborted === true)
+                    throw new MwiError('ABORTED', 'The MotionWorks engine call was cancelled.', 'Retry when the IDE is idle.');
+                if (existsSync(responsePath)) {
+                    const payload = await this.readResponse(responsePath);
+                    if (payload.ok === false) {
+                        throw new MwiError('ENGINE_REFUSED', typeof payload.error === 'string' ? payload.error : `The MotionWorks engine refused ${verb}.`, 'Read the message, correct the request, and retry. Do not retry the same invalid request.');
+                    }
+                    return payload;
+                }
+                await Promise.race([sleep(120), failure]);
+            }
+            throw new MwiError('ENGINE_TIMEOUT', `The MotionWorks code engine did not answer ${verb} within ${Math.round(timeoutMs / 1000)} s.`, 'Inspect the project files and retry; a locked or malformed project fails here.');
+        }
+        finally {
+            rmSync(ipc, { recursive: true, force: true });
+        }
+    }
+    /** Read the response file, tolerating a partial write. */
+    async readResponse(path) {
+        try {
+            const parsed = JSON.parse(readFileSync(path, 'utf8'));
+            return parsed;
+        }
+        catch {
+            await sleep(50);
+            return {};
+        }
+    }
+}

package/vendor/mwi/lib/core/errors.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Failures the model can repair from.
+ *
+ * Every expected failure carries the next call. An unexpected failure is a
+ * plugin defect and says so instead of pretending to be a project condition.
+ *
+ * @module dsh-engineering-mwi/core/errors
+ */
+/** One expected failure, with everything the reader needs to recover. */
+export declare class MwiError extends Error {
+    readonly code: string;
+    readonly fix: string;
+    readonly candidates: readonly string[];
+    /**
+     * @param code - Stable identifier for tests and logs.
+     * @param message - What failed, in the reader's terms.
+     * @param fix - The exact next call or check.
+     * @param candidates - Valid names when the request named something absent or ambiguous.
+     */
+    constructor(code: string, message: string, fix: string, candidates?: readonly string[]);
+}
+/** The model-facing failure document. */
+export interface ErrorEnvelope {
+    readonly error: {
+        readonly code: string;
+        readonly message: string;
+        readonly fix: string;
+        readonly candidates: readonly string[];
+    };
+}
+/**
+ * Convert a thrown value into the failure document.
+ *
+ * @param error - Whatever the tool body threw.
+ * @returns The failure document; never throws.
+ */
+export declare function errorEnvelope(error: unknown): ErrorEnvelope;

package/vendor/mwi/lib/core/errors.js

@@ -0,0 +1,47 @@
+/**
+ * Failures the model can repair from.
+ *
+ * Every expected failure carries the next call. An unexpected failure is a
+ * plugin defect and says so instead of pretending to be a project condition.
+ *
+ * @module dsh-engineering-mwi/core/errors
+ */
+/** One expected failure, with everything the reader needs to recover. */
+export class MwiError extends Error {
+    code;
+    fix;
+    candidates;
+    /**
+     * @param code - Stable identifier for tests and logs.
+     * @param message - What failed, in the reader's terms.
+     * @param fix - The exact next call or check.
+     * @param candidates - Valid names when the request named something absent or ambiguous.
+     */
+    constructor(code, message, fix, candidates = []) {
+        super(message);
+        this.code = code;
+        this.fix = fix;
+        this.candidates = candidates;
+        this.name = 'MwiError';
+    }
+}
+/**
+ * Convert a thrown value into the failure document.
+ *
+ * @param error - Whatever the tool body threw.
+ * @returns The failure document; never throws.
+ */
+export function errorEnvelope(error) {
+    if (error instanceof MwiError) {
+        return { error: { code: error.code, message: error.message, fix: error.fix, candidates: error.candidates } };
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+        error: {
+            code: 'INTERNAL',
+            message,
+            fix: 'This is a plugin defect, not a project condition. Report it with the arguments used, then retry.',
+            candidates: [],
+        },
+    };
+}

package/vendor/mwi/lib/core/params.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Parameter schemas that always describe themselves.
+ *
+ * MWI's legacy surface had inconsistent parameter descriptions; these helpers
+ * make an undescribed parameter impossible to write, as in the other products.
+ *
+ * @module dsh-engineering-mwi/core/params
+ */
+/** One JSON Schema property, with the description that is mandatory here. */
+export interface ParameterSchema {
+    readonly type: 'string' | 'integer' | 'number' | 'boolean' | 'array' | 'object';
+    readonly description: string;
+    readonly enum?: readonly string[];
+    readonly items?: ParameterSchema;
+    readonly default?: unknown;
+    readonly minimum?: number;
+    readonly maximum?: number;
+    readonly minItems?: number;
+    readonly maxItems?: number;
+    readonly properties?: Readonly<Record<string, ParameterSchema>>;
+    readonly required?: readonly string[];
+    readonly additionalProperties?: boolean;
+}
+/** A string parameter. */
+export declare function string(description: string, extra?: Partial<ParameterSchema>): ParameterSchema;
+/** An integer parameter with an optional range. */
+export declare function integer(description: string, extra?: Partial<ParameterSchema>): ParameterSchema;
+/** A boolean parameter. */
+export declare function boolean(description: string, extra?: Partial<ParameterSchema>): ParameterSchema;
+/** A string parameter restricted to a known set. */
+export declare function choice(description: string, values: readonly string[], extra?: Partial<ParameterSchema>): ParameterSchema;
+/** An array of one parameter type. */
+export declare function list(description: string, items: ParameterSchema, extra?: Partial<ParameterSchema>): ParameterSchema;
+/** A fixed-property object parameter. */
+export declare function record(description: string, properties: Readonly<Record<string, ParameterSchema>>, required?: readonly string[]): ParameterSchema;
+/** One object element of an array parameter. */
+export declare function objectItem(description: string, properties: Readonly<Record<string, ParameterSchema>>, required?: readonly string[]): ParameterSchema;
+/** The `parameters` object of one tool. */
+export interface Parameters {
+    readonly type: 'object';
+    readonly properties: Readonly<Record<string, ParameterSchema>>;
+    readonly required: readonly string[];
+    readonly additionalProperties: false;
+}
+/**
+ * Build a tool's parameter object.
+ *
+ * @param properties - Named parameters, each carrying its description.
+ * @param required - Names the caller must pass.
+ * @returns The open-object parameter schema.
+ */
+export declare function object(properties: Readonly<Record<string, ParameterSchema>>, required?: readonly string[]): Parameters;

package/vendor/mwi/lib/core/params.js

@@ -0,0 +1,46 @@
+/**
+ * Parameter schemas that always describe themselves.
+ *
+ * MWI's legacy surface had inconsistent parameter descriptions; these helpers
+ * make an undescribed parameter impossible to write, as in the other products.
+ *
+ * @module dsh-engineering-mwi/core/params
+ */
+/** A string parameter. */
+export function string(description, extra = {}) {
+    return { type: 'string', description, ...extra };
+}
+/** An integer parameter with an optional range. */
+export function integer(description, extra = {}) {
+    return { type: 'integer', description, ...extra };
+}
+/** A boolean parameter. */
+export function boolean(description, extra = {}) {
+    return { type: 'boolean', description, ...extra };
+}
+/** A string parameter restricted to a known set. */
+export function choice(description, values, extra = {}) {
+    return { type: 'string', description, enum: values, ...extra };
+}
+/** An array of one parameter type. */
+export function list(description, items, extra = {}) {
+    return { type: 'array', description, items, ...extra };
+}
+/** A fixed-property object parameter. */
+export function record(description, properties, required = []) {
+    return { type: 'object', description, properties, required, additionalProperties: false };
+}
+/** One object element of an array parameter. */
+export function objectItem(description, properties, required = []) {
+    return { type: 'object', description, properties, required, additionalProperties: false };
+}
+/**
+ * Build a tool's parameter object.
+ *
+ * @param properties - Named parameters, each carrying its description.
+ * @param required - Names the caller must pass.
+ * @returns The open-object parameter schema.
+ */
+export function object(properties, required = []) {
+    return { type: 'object', properties, required, additionalProperties: false };
+}

package/vendor/mwi/lib/core/ps-bridge.d.ts

@@ -0,0 +1,62 @@
+/**
+ * The PowerShell transport for the MotionWorks COM bridge.
+ *
+ * The bridge is a 32-bit PowerShell process that polls a request file and writes
+ * one response file. Files, not stdio: a confined harness cannot open named
+ * pipes, and `Mwt.exe` is a 32-bit LocalServer32 that a 64-bit client cannot
+ * instantiate at all.
+ *
+ * This client owns the mailbox, serializes requests, starts the bridge once and
+ * maps the bridge's answer onto the typed bridge contract.
+ *
+ * @module dsh-engineering-mwi/core/ps-bridge
+ */
+import type { BridgeRequest, BridgeResponse, BridgeTransport } from './bridge.ts';
+/** Where the bridge lives and which workspace it may act on. */
+export interface PowerShellBridgeOptions {
+    /** Directory containing `start_bridge.cmd` and `mw_bridge.ps1`. */
+    readonly bridgeDir: string;
+    /** Absolute workspace the bridge may touch. */
+    readonly workspace: string;
+    /** The only stage root the bridge accepts: `<workspace>/.motionworks/stage`. */
+    readonly stageRoot: string;
+    /** Mailbox directory; defaults to a private temp directory. */
+    readonly ipcDir?: string;
+    /** Startup budget before the bridge must answer. Defaults to 12 s. */
+    readonly startupMs?: number;
+}
+/**
+ * A serialized client over the file mailbox, matching the legacy bridge protocol.
+ */
+export declare class PowerShellBridgeTransport implements BridgeTransport {
+    private readonly options;
+    private readonly ipcDir;
+    private readonly requestPath;
+    private readonly responsePath;
+    private readonly startupMs;
+    private spawned;
+    private queue;
+    /**
+     * @param options - Bridge location and workspace authorization.
+     */
+    constructor(options: PowerShellBridgeOptions);
+    /** The mailbox this client owns; exposed for diagnostics. */
+    get mailbox(): string;
+    /**
+     * Send one request and wait for its response.
+     *
+     * @param request - Operation and arguments.
+     * @param timeoutMs - Hard operation budget.
+     * @param signal - Cancellation owned by the caller.
+     * @returns The bridge's answer.
+     */
+    send(request: BridgeRequest, timeoutMs: number, signal?: AbortSignal): Promise<BridgeResponse>;
+    /** Run one request after the previous one settled. */
+    private exchange;
+    /** Read the current response file, ignoring partial or malformed writes. */
+    private readResponse;
+    /** Map a bridge refusal to a stable code the model can act on. */
+    private codeOf;
+    /** Start the 32-bit bridge once per client. */
+    private spawnBridge;
+}