@crosshands/platform-windows 0.1.2

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+import { type ComputerOperationName, type ReferenceBindings } from '@crosshands/contract';
+import type { BrokerEndpoint, LocalControlIdentity, LocalControlRequest, StableAppIdentity } from '@crosshands/runtime';
+import { WindowsComputerProvider } from './provider.js';
+import { type WindowsRelayControlServer } from './windows-control-security.js';
+export declare const packageVersion: "0.1.2";
+export * from './provider.js';
+export * from './security.js';
+export * from './windows-control-security.js';
+type PlatformControlServerOptions = {
+    endpoint: BrokerEndpoint;
+    identity: LocalControlIdentity;
+    handler: (request: LocalControlRequest) => Promise<unknown>;
+};
+export declare function createControlServer(options: PlatformControlServerOptions): Promise<WindowsRelayControlServer>;
+export declare function createProvider(): WindowsComputerProvider;
+export declare function inspectTarget(operation: ComputerOperationName, input: unknown): Promise<{
+    bindings: ReferenceBindings;
+    appIdentity: StableAppIdentity;
+} | null>;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAEL,KAAK,qBAAqB,EAC1B,KAAK,iBAAiB,EACvB,MAAM,sBAAsB,CAAA;AAC7B,OAAO,KAAK,EACV,cAAc,EACd,oBAAoB,EACpB,mBAAmB,EACnB,iBAAiB,EAClB,MAAM,qBAAqB,CAAA;AAE5B,OAAO,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAA;AACvD,OAAO,EAEL,KAAK,yBAAyB,EAC/B,MAAM,+BAA+B,CAAA;AAEtC,eAAO,MAAM,cAAc,SAA4B,CAAA;AAEvD,cAAc,eAAe,CAAA;AAC7B,cAAc,eAAe,CAAA;AAC7B,cAAc,+BAA+B,CAAA;AAK7C,KAAK,4BAA4B,GAAG;IAClC,QAAQ,EAAE,cAAc,CAAA;IACxB,QAAQ,EAAE,oBAAoB,CAAA;IAC9B,OAAO,EAAE,CAAC,OAAO,EAAE,mBAAmB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;CAC5D,CAAA;AAED,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,4BAA4B,GACpC,OAAO,CAAC,yBAAyB,CAAC,CAoBpC;AAID,wBAAgB,cAAc,IAAI,uBAAuB,CAGxD;AAED,wBAAsB,aAAa,CACjC,SAAS,EAAE,qBAAqB,EAChC,KAAK,EAAE,OAAO,GACb,OAAO,CAAC;IAAE,QAAQ,EAAE,iBAAiB,CAAC;IAAC,WAAW,EAAE,iBAAiB,CAAA;CAAE,GAAG,IAAI,CAAC,CAKjF"}

package/dist/index.js

@@ -0,0 +1,42 @@
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { CONTRACT_VERSIONS } from '@crosshands/contract';
+import { WindowsComputerProvider } from './provider.js';
+import { createWindowsControlServer as createWindowsRelayControlServer } from './windows-control-security.js';
+export const packageVersion = CONTRACT_VERSIONS.product;
+export * from './provider.js';
+export * from './security.js';
+export * from './windows-control-security.js';
+const PAYLOAD_MANIFEST = fileURLToPath(new URL('../assets/payload.json', import.meta.url));
+const CONTROL_RELAY = fileURLToPath(new URL('../assets/crosshands-pipe-relay.exe', import.meta.url));
+export async function createControlServer(options) {
+    if (options.endpoint.transport !== 'named-pipe') {
+        throw new Error('Windows control relay requires a named-pipe endpoint');
+    }
+    const manifest = JSON.parse(await readFile(PAYLOAD_MANIFEST, 'utf8'));
+    const helperSha256 = manifest.files?.['crosshands-pipe-relay.exe'];
+    if (typeof helperSha256 !== 'string' || !/^[a-f0-9]{64}$/.test(helperSha256)) {
+        throw new Error('Windows control relay is missing payload hash metadata');
+    }
+    return createWindowsRelayControlServer({
+        identity: options.identity,
+        relay: {
+            helperPath: CONTROL_RELAY,
+            helperSha256,
+            pipeName: options.endpoint.address
+        },
+        handler: options.handler
+    });
+}
+let sharedProvider;
+export function createProvider() {
+    sharedProvider = new WindowsComputerProvider();
+    return sharedProvider;
+}
+export async function inspectTarget(operation, input) {
+    if (sharedProvider === undefined) {
+        throw new Error('createProvider() must be called before inspectTarget()');
+    }
+    return sharedProvider.inspect(operation, input);
+}
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAC3C,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAExC,OAAO,EACL,iBAAiB,EAGlB,MAAM,sBAAsB,CAAA;AAQ7B,OAAO,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAA;AACvD,OAAO,EACL,0BAA0B,IAAI,+BAA+B,EAE9D,MAAM,+BAA+B,CAAA;AAEtC,MAAM,CAAC,MAAM,cAAc,GAAG,iBAAiB,CAAC,OAAO,CAAA;AAEvD,cAAc,eAAe,CAAA;AAC7B,cAAc,eAAe,CAAA;AAC7B,cAAc,+BAA+B,CAAA;AAE7C,MAAM,gBAAgB,GAAG,aAAa,CAAC,IAAI,GAAG,CAAC,wBAAwB,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAA;AAC1F,MAAM,aAAa,GAAG,aAAa,CAAC,IAAI,GAAG,CAAC,qCAAqC,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAA;AAQpG,MAAM,CAAC,KAAK,UAAU,mBAAmB,CACvC,OAAqC;IAErC,IAAI,OAAO,CAAC,QAAQ,CAAC,SAAS,KAAK,YAAY,EAAE,CAAC;QAChD,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAA;IACzE,CAAC;IACD,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC,CAEnE,CAAA;IACD,MAAM,YAAY,GAAG,QAAQ,CAAC,KAAK,EAAE,CAAC,2BAA2B,CAAC,CAAA;IAClE,IAAI,OAAO,YAAY,KAAK,QAAQ,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,YAAY,CAAC,EAAE,CAAC;QAC7E,MAAM,IAAI,KAAK,CAAC,wDAAwD,CAAC,CAAA;IAC3E,CAAC;IACD,OAAO,+BAA+B,CAAC;QACrC,QAAQ,EAAE,OAAO,CAAC,QAAQ;QAC1B,KAAK,EAAE;YACL,UAAU,EAAE,aAAa;YACzB,YAAY;YACZ,QAAQ,EAAE,OAAO,CAAC,QAAQ,CAAC,OAAO;SACnC;QACD,OAAO,EAAE,OAAO,CAAC,OAAO;KACzB,CAAC,CAAA;AACJ,CAAC;AAED,IAAI,cAAmD,CAAA;AAEvD,MAAM,UAAU,cAAc;IAC5B,cAAc,GAAG,IAAI,uBAAuB,EAAE,CAAA;IAC9C,OAAO,cAAc,CAAA;AACvB,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,aAAa,CACjC,SAAgC,EAChC,KAAc;IAEd,IAAI,cAAc,KAAK,SAAS,EAAE,CAAC;QACjC,MAAM,IAAI,KAAK,CAAC,wDAAwD,CAAC,CAAA;IAC3E,CAAC;IACD,OAAO,cAAc,CAAC,OAAO,CAAC,SAAS,EAAE,KAAK,CAAC,CAAA;AACjD,CAAC"}

package/dist/provider.d.ts

@@ -0,0 +1,51 @@
+import { type ComputerOperationName, type ComputerProvider, type ProviderHandshake, type ProviderRequest, type ProviderResponse, type ReferenceBindings } from '@crosshands/contract';
+import type { StableAppIdentity } from '@crosshands/runtime';
+type JsonRecord = Record<string, unknown>;
+export type NativeFrame = {
+    ok: boolean;
+    error?: string;
+} & JsonRecord;
+export type PowerShellLaunchSpec = {
+    executable: string;
+    args: string[];
+    env: NodeJS.ProcessEnv;
+};
+export declare function windowsPowerShellLaunchSpec(scriptPath: string, env?: NodeJS.ProcessEnv): PowerShellLaunchSpec;
+export interface NativeWindowsTransport {
+    start(): Promise<NativeFrame>;
+    request(payload: JsonRecord, deadlineAt: number): Promise<NativeFrame>;
+    cancel(): Promise<void>;
+    close(): Promise<void>;
+}
+export declare class PowerShellStdioTransport implements NativeWindowsTransport {
+    #private;
+    constructor(scriptPath: string);
+    start(): Promise<NativeFrame>;
+    request(payload: JsonRecord, deadlineAt: number): Promise<NativeFrame>;
+    cancel(): Promise<void>;
+    close(): Promise<void>;
+}
+type WindowsProviderOptions = {
+    scriptPath?: string;
+    manifestPath?: string;
+    transport?: NativeWindowsTransport;
+    graphicalSessionId?: string;
+    skipPayloadVerification?: boolean;
+};
+export declare function verifyWindowsPayload(scriptPath?: string, manifestPath?: string): Promise<void>;
+export declare class WindowsComputerProvider implements ComputerProvider {
+    #private;
+    readonly generation: string;
+    constructor(options?: WindowsProviderOptions);
+    start(): Promise<ProviderHandshake>;
+    dispatch(request: ProviderRequest): Promise<ProviderResponse>;
+    inspect(operation: ComputerOperationName, input: unknown): Promise<{
+        bindings: ReferenceBindings;
+        appIdentity: StableAppIdentity;
+    } | null>;
+    cancel(_requestId: string): Promise<void>;
+    close(): Promise<void>;
+}
+export declare function normalizeScreenshotIssues(value: unknown): JsonRecord[];
+export {};
+//# sourceMappingURL=provider.d.ts.map

package/dist/provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../src/provider.ts"],"names":[],"mappings":"AAOA,OAAO,EAIL,KAAK,qBAAqB,EAC1B,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACvB,MAAM,sBAAsB,CAAA;AAC7B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AAE5D,KAAK,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAazC,MAAM,MAAM,WAAW,GAAG;IAAE,EAAE,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,UAAU,CAAA;AAEtE,MAAM,MAAM,oBAAoB,GAAG;IACjC,UAAU,EAAE,MAAM,CAAA;IAClB,IAAI,EAAE,MAAM,EAAE,CAAA;IACd,GAAG,EAAE,MAAM,CAAC,UAAU,CAAA;CACvB,CAAA;AAED,wBAAgB,2BAA2B,CACzC,UAAU,EAAE,MAAM,EAClB,GAAG,GAAE,MAAM,CAAC,UAAwB,GACnC,oBAAoB,CAmCtB;AAED,MAAM,WAAW,sBAAsB;IACrC,KAAK,IAAI,OAAO,CAAC,WAAW,CAAC,CAAA;IAC7B,OAAO,CAAC,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAAA;IACtE,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IACvB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACvB;AAED,qBAAa,wBAAyB,YAAW,sBAAsB;;gBAWzD,UAAU,EAAE,MAAM;IAIxB,KAAK,IAAI,OAAO,CAAC,WAAW,CAAC;IAoCnC,OAAO,CAAC,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;IAoChE,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAIvB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAsD7B;AAED,KAAK,sBAAsB,GAAG;IAC5B,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,SAAS,CAAC,EAAE,sBAAsB,CAAA;IAClC,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B,uBAAuB,CAAC,EAAE,OAAO,CAAA;CAClC,CAAA;AAKD,wBAAsB,oBAAoB,CACxC,UAAU,SAAkB,EAC5B,YAAY,SAAoB,GAC/B,OAAO,CAAC,IAAI,CAAC,CAqBf;AAsDD,qBAAa,uBAAwB,YAAW,gBAAgB;;IAC9D,QAAQ,CAAC,UAAU,SAA4B;gBAUnC,OAAO,GAAE,sBAA2B;IAa1C,KAAK,IAAI,OAAO,CAAC,iBAAiB,CAAC;IA2BnC,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAmC7D,OAAO,CACX,SAAS,EAAE,qBAAqB,EAChC,KAAK,EAAE,OAAO,GACb,OAAO,CAAC;QACT,QAAQ,EAAE,iBAAiB,CAAA;QAC3B,WAAW,EAAE,iBAAiB,CAAA;KAC/B,GAAG,IAAI,CAAC;IAgCH,MAAM,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIzC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAyL7B;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,OAAO,GAAG,UAAU,EAAE,CAMtE"}

package/dist/provider.js

@@ -0,0 +1,547 @@
+import { spawn } from 'node:child_process';
+import { createHash, randomUUID } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
+import { createInterface } from 'node:readline';
+import { isAbsolute, win32 } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { COMPUTER_OPERATIONS, CONTRACT_VERSIONS, createComputerError } from '@crosshands/contract';
+export function windowsPowerShellLaunchSpec(scriptPath, env = process.env) {
+    const systemRoot = env.SystemRoot ?? env.SYSTEMROOT ?? 'C:\\Windows';
+    const executable = win32.join(systemRoot, 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe');
+    const absoluteScript = win32.isAbsolute(scriptPath)
+        ? win32.normalize(scriptPath)
+        : win32.resolve(scriptPath);
+    return {
+        executable,
+        args: [
+            '-NoLogo',
+            '-NoProfile',
+            '-NonInteractive',
+            '-ExecutionPolicy',
+            'Bypass',
+            '-File',
+            absoluteScript
+        ],
+        env: {
+            SystemRoot: systemRoot,
+            WINDIR: env.WINDIR ?? systemRoot,
+            TEMP: env.TEMP ?? win32.join(systemRoot, 'Temp'),
+            TMP: env.TMP ?? env.TEMP ?? win32.join(systemRoot, 'Temp'),
+            USERPROFILE: env.USERPROFILE,
+            LOCALAPPDATA: env.LOCALAPPDATA,
+            APPDATA: env.APPDATA,
+            PSModuleAutoLoadingPreference: 'None',
+            POWERSHELL_TELEMETRY_OPTOUT: '1'
+        }
+    };
+}
+export class PowerShellStdioTransport {
+    #launch;
+    #child;
+    #ready;
+    #resolveReady;
+    #rejectReady;
+    #active;
+    #tail = Promise.resolve();
+    constructor(scriptPath) {
+        this.#launch = windowsPowerShellLaunchSpec(scriptPath);
+    }
+    async start() {
+        if (this.#ready !== undefined)
+            return this.#ready;
+        this.#ready = new Promise((resolveReady, rejectReady) => {
+            this.#resolveReady = resolveReady;
+            this.#rejectReady = rejectReady;
+        });
+        const child = spawn(this.#launch.executable, this.#launch.args, {
+            env: this.#launch.env,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            windowsHide: true,
+            shell: false
+        });
+        this.#child = child;
+        const lines = createInterface({ input: child.stdout, crlfDelay: Number.POSITIVE_INFINITY });
+        lines.on('line', (line) => this.#receive(line));
+        let stderr = '';
+        child.stderr.setEncoding('utf8');
+        child.stderr.on('data', (chunk) => {
+            if (stderr.length < 8_192)
+                stderr += chunk.slice(0, 8_192 - stderr.length);
+        });
+        child.once('error', (cause) => this.#fail(cause, child));
+        child.once('exit', (code) => this.#fail(createComputerError('provider_crashed', `Windows provider exited with code ${String(code)}`, {
+            stderr
+        }), child));
+        return this.#ready;
+    }
+    request(payload, deadlineAt) {
+        const result = this.#tail.then(async () => {
+            await this.start();
+            if (deadlineAt <= Date.now())
+                throw createComputerError('timeout', 'Request deadline elapsed');
+            const child = this.#child;
+            if (child === undefined || !child.stdin.writable)
+                throw createComputerError('provider_unavailable', 'Windows provider stdin is unavailable');
+            return new Promise((resolveFrame, rejectFrame) => {
+                const timer = setTimeout(() => {
+                    this.#active = undefined;
+                    if (this.#child === child) {
+                        this.#child = undefined;
+                        this.#ready = undefined;
+                        this.#resolveReady = undefined;
+                        this.#rejectReady = undefined;
+                    }
+                    child.kill();
+                    rejectFrame(createComputerError('timeout', 'Windows provider request timed out'));
+                }, Math.max(1, deadlineAt - Date.now()));
+                timer.unref();
+                this.#active = { resolve: resolveFrame, reject: rejectFrame, timer };
+                child.stdin.write(`${JSON.stringify(payload)}\n`, 'utf8', (cause) => {
+                    if (cause !== null && cause !== undefined)
+                        this.#fail(cause, child);
+                });
+            });
+        });
+        this.#tail = result.then(() => undefined, () => undefined);
+        return result;
+    }
+    async cancel() {
+        this.#child?.kill();
+    }
+    async close() {
+        const child = this.#child;
+        this.#child = undefined;
+        this.#ready = undefined;
+        this.#resolveReady = undefined;
+        this.#rejectReady = undefined;
+        child?.stdin.end();
+        child?.kill();
+    }
+    #receive(line) {
+        let frame;
+        try {
+            frame = JSON.parse(line);
+        }
+        catch {
+            this.#fail(createComputerError('provider_crashed', 'Windows provider emitted non-JSON stdout'));
+            return;
+        }
+        if (this.#resolveReady !== undefined) {
+            const resolveReady = this.#resolveReady;
+            this.#resolveReady = undefined;
+            this.#rejectReady = undefined;
+            resolveReady(frame);
+            return;
+        }
+        const active = this.#active;
+        if (active === undefined) {
+            this.#fail(createComputerError('provider_crashed', 'Windows provider emitted an unsolicited frame'));
+            return;
+        }
+        this.#active = undefined;
+        clearTimeout(active.timer);
+        active.resolve(frame);
+    }
+    #fail(cause, source) {
+        if (source !== undefined && this.#child !== source)
+            return;
+        this.#child = undefined;
+        this.#ready = undefined;
+        const rejectReady = this.#rejectReady;
+        this.#resolveReady = undefined;
+        this.#rejectReady = undefined;
+        rejectReady?.(cause);
+        const active = this.#active;
+        this.#active = undefined;
+        if (active !== undefined) {
+            clearTimeout(active.timer);
+            active.reject(cause);
+        }
+    }
+}
+const PACKAGED_SCRIPT = fileURLToPath(new URL('../assets/runtime.ps1', import.meta.url));
+const PACKAGED_MANIFEST = fileURLToPath(new URL('../assets/payload.json', import.meta.url));
+export async function verifyWindowsPayload(scriptPath = PACKAGED_SCRIPT, manifestPath = PACKAGED_MANIFEST) {
+    if (!isAbsolute(scriptPath) || !isAbsolute(manifestPath)) {
+        throw createComputerError('provider_unavailable', 'Windows payload paths must be absolute');
+    }
+    const manifest = JSON.parse(await readFile(manifestPath, 'utf8'));
+    if (manifest.productVersion !== CONTRACT_VERSIONS.product) {
+        throw createComputerError('version_incompatible', 'Windows payload product version mismatch');
+    }
+    const expected = manifest.files?.['runtime.ps1'];
+    if (typeof expected !== 'string' || !/^[a-f0-9]{64}$/.test(expected)) {
+        throw createComputerError('provider_unavailable', 'Windows payload manifest is malformed');
+    }
+    const actual = createHash('sha256')
+        .update(await readFile(scriptPath))
+        .digest('hex');
+    if (actual !== expected) {
+        throw createComputerError('provider_unavailable', 'Windows provider payload hash mismatch');
+    }
+}
+function record(value) {
+    return value !== null && typeof value === 'object' ? value : {};
+}
+function errorCode(message) {
+    const normalized = message.toLowerCase();
+    if (normalized.includes('appblocked'))
+        return 'app_blocked';
+    if (normalized.includes('appnotfound'))
+        return 'app_not_found';
+    if (normalized.includes('windownotfound'))
+        return 'window_not_found';
+    if (normalized.includes('window_not_focused'))
+        return 'window_not_focused';
+    if (normalized.includes('stale_target') || normalized.includes('stale element'))
+        return 'stale_target';
+    if (normalized.includes('session_unavailable'))
+        return 'session_unavailable';
+    if (normalized.includes('unsupported_capability'))
+        return 'unsupported_capability';
+    if (normalized.includes('not settable'))
+        return 'value_not_settable';
+    if (normalized.includes('unknown element'))
+        return 'element_not_found';
+    if (normalized.includes('unsupported'))
+        return 'action_not_supported';
+    return 'accessibility_error';
+}
+function isPreDispatchFailure(message) {
+    return /^(app|window).*notfound|appblocked|session_unavailable|unsupported_capability|stale_target|window_not_focused/i.test(message);
+}
+function executableId(identity) {
+    const raw = `${identity.executablePath}|il:${identity.integrityRid}|pub:${identity.publisher}|sha256:${identity.sha256}`;
+    return raw.length <= 512 ? raw : `sha256:${createHash('sha256').update(raw).digest('hex')}`;
+}
+function targetReference(input) {
+    const candidates = [input.target, input.from, input.to];
+    for (const candidate of candidates) {
+        const candidateRecord = record(candidate);
+        if (candidateRecord.kind === 'element')
+            return record(candidateRecord.ref);
+        if ('contextToken' in candidateRecord)
+            return candidateRecord;
+        if (candidateRecord.kind === 'coordinate')
+            return record(candidateRecord.window);
+    }
+    return {};
+}
+function setBounded(map, key, value) {
+    map.delete(key);
+    map.set(key, value);
+    while (map.size > 32) {
+        const oldest = map.keys().next().value;
+        if (oldest === undefined)
+            return;
+        map.delete(oldest);
+    }
+}
+export class WindowsComputerProvider {
+    generation = `windows-${randomUUID()}`;
+    #transport;
+    #graphicalSessionId;
+    #scriptPath;
+    #manifestPath;
+    #skipPayloadVerification;
+    #snapshots = new Map();
+    #identities = new Map();
+    #handshake;
+    constructor(options = {}) {
+        this.#scriptPath = options.scriptPath ?? PACKAGED_SCRIPT;
+        this.#manifestPath = options.manifestPath ?? PACKAGED_MANIFEST;
+        this.#skipPayloadVerification =
+            options.skipPayloadVerification ?? options.transport !== undefined;
+        this.#transport = options.transport ?? new PowerShellStdioTransport(this.#scriptPath);
+        this.#graphicalSessionId =
+            options.graphicalSessionId ??
+                process.env.CROSSHANDS_GRAPHICAL_SESSION_ID ??
+                process.env.SESSIONNAME ??
+                'win32:interactive';
+    }
+    async start() {
+        if (this.#handshake !== undefined)
+            return this.#handshake;
+        if (!this.#skipPayloadVerification) {
+            await verifyWindowsPayload(this.#scriptPath, this.#manifestPath);
+        }
+        const ready = await this.#transport.start();
+        if (!ready.ok || ready.ready !== true)
+            throw createComputerError('provider_unavailable', 'Windows provider readiness failed');
+        this.#handshake = {
+            provider: 'crosshands-platform-windows',
+            generation: this.generation,
+            graphicalSessionId: this.#graphicalSessionId,
+            providerProtocol: CONTRACT_VERSIONS.providerProtocol,
+            publicContract: CONTRACT_VERSIONS.publicContract,
+            capabilities: {
+                platform: 'win32',
+                provider: 'crosshands-platform-windows',
+                providerVersion: CONTRACT_VERSIONS.product,
+                operations: Object.fromEntries(Object.keys(COMPUTER_OPERATIONS).map((operation) => [operation, true])),
+                permissions: { accessibility: 'not_required', screenshots: 'not_required' }
+            }
+        };
+        return this.#handshake;
+    }
+    async dispatch(request) {
+        await this.start();
+        if (request.operation === 'capabilities')
+            return {
+                requestId: request.requestId,
+                dispatched: false,
+                result: this.#handshake.capabilities
+            };
+        if (request.operation === 'permissions')
+            return {
+                requestId: request.requestId,
+                dispatched: false,
+                result: { permissions: this.#handshake.capabilities.permissions }
+            };
+        const input = record(request.input);
+        const nativeInput = this.#nativeInput(request.operation, input);
+        const frame = await this.#transport.request(nativeInput, request.deadlineAt);
+        if (!frame.ok) {
+            const message = frame.error ?? 'Windows provider operation failed';
+            const dispatched = COMPUTER_OPERATIONS[request.operation].mutation
+                ? !isPreDispatchFailure(message)
+                : false;
+            return {
+                requestId: request.requestId,
+                dispatched,
+                error: createComputerError(errorCode(message), message).toJSON()
+            };
+        }
+        return {
+            requestId: request.requestId,
+            dispatched: COMPUTER_OPERATIONS[request.operation].mutation,
+            result: this.#normalizeResult(request.operation, frame)
+        };
+    }
+    async inspect(operation, input) {
+        if (!COMPUTER_OPERATIONS[operation].mutation)
+            return null;
+        const inputRecord = record(input);
+        const reference = targetReference(inputRecord);
+        const app = String(inputRecord.app ?? reference.appId ?? '');
+        if (app.length === 0)
+            return null;
+        await this.start();
+        const frame = await this.#transport.request({ tool: 'inspect_target', app }, Date.now() + 5_000);
+        if (!frame.ok)
+            throw createComputerError(errorCode(frame.error ?? ''), frame.error ?? 'Inspect failed');
+        const identity = frame.identity;
+        setBounded(this.#identities, app, identity);
+        const nativeExecutableId = executableId(identity);
+        return {
+            bindings: {
+                brokerGeneration: String(reference.brokerGeneration ?? 'unbound'),
+                providerGeneration: this.generation,
+                graphicalSessionId: this.#graphicalSessionId,
+                process: {
+                    pid: identity.pid,
+                    startedAt: identity.startedAt,
+                    executableId: nativeExecutableId
+                },
+                appId: String(frame.appId),
+                window: { id: String(frame.windowId), ownerPid: identity.pid },
+                snapshotId: String(reference.snapshotId ?? 'inspection'),
+                desktopEpoch: Number(reference.desktopEpoch ?? 0)
+            },
+            appIdentity: { appId: String(frame.appId), executableId: nativeExecutableId }
+        };
+    }
+    async cancel(_requestId) {
+        await this.#transport.cancel();
+    }
+    async close() {
+        this.#handshake = undefined;
+        this.#snapshots.clear();
+        this.#identities.clear();
+        await this.#transport.close();
+    }
+    #nativeInput(operation, input) {
+        const toolNames = {
+            listApps: 'list_apps',
+            listWindows: 'list_windows',
+            getAppState: 'get_app_state',
+            performSecondaryAction: 'perform_secondary_action',
+            typeText: 'type_text',
+            pressKey: 'press_key',
+            pasteText: 'paste_text',
+            setValue: 'set_value'
+        };
+        const tool = toolNames[operation] ?? operation;
+        const reference = targetReference(input);
+        const app = String(input.app ?? reference.appId ?? '');
+        const cached = this.#snapshots.get(app);
+        const target = record(input.target);
+        const from = record(input.from);
+        const to = record(input.to);
+        const elementFor = (candidate) => {
+            if (candidate.kind !== 'element')
+                return undefined;
+            const ref = record(candidate.ref);
+            const index = Number(String(ref.ref ?? '').replace(/^element:/, ''));
+            const elements = Array.isArray(cached?.elements) ? cached.elements : [];
+            return Number.isInteger(index) ? elements[index] : undefined;
+        };
+        return {
+            tool,
+            app,
+            noScreenshot: input.captureScreenshot === false,
+            restoreWindow: input.restoreWindow === true,
+            expectedIdentity: this.#identities.get(app),
+            windowId: reference.window !== undefined ? record(reference.window).id : cached?.windowId,
+            windowBounds: cached?.windowBounds,
+            element: elementFor(target),
+            fromElement: elementFor(from),
+            toElement: elementFor(to),
+            x: target.x,
+            y: target.y,
+            from_x: from.x,
+            from_y: from.y,
+            to_x: to.x,
+            to_y: to.y,
+            duration_ms: input.durationMs,
+            click_count: input.clickCount,
+            mouse_button: input.button,
+            modifiers: input.modifiers,
+            action: input.action,
+            direction: input.direction,
+            pages: input.pages,
+            text: input.text,
+            key: Array.isArray(input.keys) ? input.keys.join('+') : input.key,
+            value: input.value,
+            ...(operation === 'getAppState'
+                ? {
+                    windowId: record(input.window).id,
+                    windowIndex: record(input.window).index
+                }
+                : {})
+        };
+    }
+    #normalizeResult(operation, frame) {
+        if (operation === 'listApps') {
+            return {
+                apps: (Array.isArray(frame.apps) ? frame.apps : []).map((value) => {
+                    const app = record(value);
+                    return {
+                        id: String(app.bundleId),
+                        name: String(app.name),
+                        bundleId: String(app.bundleId),
+                        pid: Number(app.pid),
+                        isRunning: true
+                    };
+                })
+            };
+        }
+        if (operation === 'listWindows') {
+            return {
+                windows: (Array.isArray(frame.windows) ? frame.windows : []).map((value) => {
+                    const window = record(value);
+                    const app = record(window.app);
+                    return {
+                        id: String(window.id),
+                        appId: String(app.bundleId),
+                        title: String(window.title ?? ''),
+                        index: Number(window.index),
+                        bounds: {
+                            x: Number(window.x ?? 0),
+                            y: Number(window.y ?? 0),
+                            width: Math.max(1, Number(window.width ?? 1)),
+                            height: Math.max(1, Number(window.height ?? 1))
+                        },
+                        minimized: Boolean(window.isMinimized)
+                    };
+                })
+            };
+        }
+        if (operation === 'getAppState')
+            return this.#snapshotResult(record(frame.snapshot));
+        const action = record(frame.action);
+        const verification = record(action.verification);
+        return {
+            outcome: verification.state === 'verified'
+                ? { state: 'verified', evidence: verification }
+                : {
+                    state: 'indeterminate',
+                    reason: String(verification.reason ?? 'native_action_unverified')
+                },
+            freshState: this.#snapshotResult(record(frame.snapshot))
+        };
+    }
+    #snapshotResult(native) {
+        const app = record(native.app);
+        const identity = native.processIdentity;
+        const bounds = record(native.windowBounds);
+        const appId = String(app.bundleId);
+        setBounded(this.#snapshots, appId, native);
+        setBounded(this.#identities, appId, identity);
+        const snapshot = {
+            id: String(native.snapshotId),
+            app: {
+                id: appId,
+                name: String(app.name),
+                bundleId: appId,
+                pid: Number(app.pid),
+                isRunning: true
+            },
+            window: {
+                id: String(native.windowId),
+                appId,
+                title: String(native.windowTitle ?? ''),
+                index: 0,
+                bounds: {
+                    x: Number(bounds.x ?? 0),
+                    y: Number(bounds.y ?? 0),
+                    width: Math.max(1, Number(bounds.width ?? 1)),
+                    height: Math.max(1, Number(bounds.height ?? 1))
+                },
+                minimized: false
+            },
+            treeText: (Array.isArray(native.treeLines) ? native.treeLines : []).join('\n'),
+            elementCount: Array.isArray(native.elements) ? native.elements.length : 0,
+            focusedElementRef: native.focusedElementId === null || native.focusedElementId === undefined
+                ? null
+                : String(native.focusedElementId),
+            desktopEpoch: 0
+        };
+        return {
+            bindings: {
+                brokerGeneration: 'unbound',
+                providerGeneration: this.generation,
+                graphicalSessionId: this.#graphicalSessionId,
+                process: {
+                    pid: identity.pid,
+                    startedAt: identity.startedAt,
+                    executableId: executableId(identity)
+                },
+                appId,
+                window: { id: String(native.windowId), ownerPid: identity.pid },
+                snapshotId: String(native.snapshotId),
+                desktopEpoch: 0
+            },
+            snapshot,
+            screenshot: typeof native.screenshotPngBase64 === 'string'
+                ? {
+                    format: 'png',
+                    width: Number(native.screenshotWidth),
+                    height: Number(native.screenshotHeight),
+                    scale: Number(native.screenshotScale),
+                    data: native.screenshotPngBase64
+                }
+                : null,
+            issues: normalizeScreenshotIssues(native.screenshotError)
+        };
+    }
+}
+export function normalizeScreenshotIssues(value) {
+    const error = record(value);
+    if (typeof error.message !== 'string' || error.message.length === 0)
+        return [];
+    return [
+        createComputerError('screenshot_failed', error.message, { component: 'screenshots' }).toJSON()
+    ];
+}
+//# sourceMappingURL=provider.js.map