@dopame/acde-linux-x64 0.0.0-stage → 0.0.10

package/lib/acde/dist/types/driver/window.d.ts

@@ -0,0 +1,77 @@
+import type { InspectWindow } from '@dopame/acde-api';
+import { type Acde, type ActResult, type ConsoleEntry, type ConsoleOptions, type DevPage, type Dialog, type DialogAnswer, type DialogType, type DropOptions, type Dropped, type NetworkOptions, type RequestEntry, type RouteOptions, type RouteResponse, type Shot, type UrlMatch, type WaitConsoleOptions, type WaitRequestOptions } from './acde.ts';
+import { Locator, type RoleOptions, type Scope, type Source, type TextMatch, type TextOptions, type Timeout, type Tree } from './locator.ts';
+import { Clock } from './clock.ts';
+import { Keyboard, Mouse } from './input.ts';
+import { type Capture, type ScreenshotOptions } from './screenshot.ts';
+export interface WindowMatch {
+    readonly ref?: string;
+    readonly id?: number;
+    readonly app?: string;
+    readonly title?: TextMatch;
+}
+export declare class AppWindow implements Scope {
+    #private;
+    readonly acde: Acde;
+    readonly match: WindowMatch;
+    readonly mouse: Mouse;
+    readonly keyboard: Keyboard;
+    readonly clock: Clock;
+    constructor(acde: Acde, match: WindowMatch);
+    describe(): string;
+    toString(): string;
+    static pick(windows: readonly InspectWindow[], match: WindowMatch): InspectWindow[];
+    find(): Promise<InspectWindow | null>;
+    info(options?: Timeout): Promise<InspectWindow>;
+    isOpen(): Promise<boolean>;
+    waitFor(options?: Timeout & {
+        readonly state?: 'open' | 'closed';
+    }): Promise<void>;
+    tree(): Promise<Tree>;
+    static source(acde: Acde, ref: string): Promise<Source>;
+    getByRole(role: string, options?: RoleOptions): Locator;
+    getByText(text: TextMatch, options?: TextOptions): Locator;
+    locator(selector: string): Locator;
+    getByTestId(id: string): Locator;
+    getByLabel(text: TextMatch, options?: TextOptions): Locator;
+    getByPlaceholder(text: TextMatch, options?: TextOptions): Locator;
+    getByTitle(text: TextMatch, options?: TextOptions): Locator;
+    getByAltText(text: TextMatch, options?: TextOptions): Locator;
+    route(url: UrlMatch, response: RouteResponse, options?: Omit<RouteOptions, 'web'>): Promise<number>;
+    drop(files: string | readonly string[], options?: Omit<DropOptions, 'web'>): Promise<Dropped>;
+    waitForRequest(url: UrlMatch, options?: Omit<WaitRequestOptions, 'web'>): Promise<RequestEntry>;
+    waitForConsole(text: string | RegExp, options?: Omit<WaitConsoleOptions, 'web'>): Promise<ConsoleEntry>;
+    addInitScript(code: string, options?: {
+        readonly once?: boolean;
+    }): Promise<number>;
+    reload(options?: Timeout): Promise<void>;
+    resize(width: number, height: number, options?: Timeout): Promise<{
+        width: number;
+        height: number;
+    }>;
+    seedLocalStorage(entries: Readonly<Record<string, string>>, options?: Timeout): Promise<void>;
+    answerDialog(answer?: DialogAnswer): Promise<void>;
+    dialogs(): Promise<Dialog[]>;
+    waitForDialog(options?: {
+        readonly type?: DialogType;
+        readonly timeout?: number;
+    }): Promise<Dialog>;
+    console(options?: Omit<ConsoleOptions, 'web'>): Promise<DevPage<ConsoleEntry>>;
+    network(options?: Omit<NetworkOptions, 'web'>): Promise<DevPage<RequestEntry>>;
+    snapshot(options?: {
+        readonly find?: string;
+        readonly diff?: boolean;
+    }): Promise<string>;
+    web(): Promise<string>;
+    evaluate<T = unknown>(code: string): Promise<NoInfer<T>>;
+    screenshot(options?: ScreenshotOptions): Promise<Shot>;
+    capture(): Promise<Capture>;
+    rects(): Promise<readonly (readonly [number, number, number, number])[]>;
+    press(keys: string): Promise<ActResult>;
+    focus(): Promise<ActResult>;
+    minimize(): Promise<ActResult>;
+    restore(): Promise<ActResult>;
+    fill(): Promise<ActResult>;
+    fullscreen(): Promise<ActResult>;
+    close(): Promise<ActResult>;
+}

package/lib/acde/dist/types/e2e/index.d.ts

@@ -0,0 +1,78 @@
+import { type Matchers } from 'bun:test';
+import { Acde } from '../driver/acde.ts';
+import { type LocatorAssertions, type WindowAssertions } from '../driver/expect.ts';
+import { Locator } from '../driver/locator.ts';
+import { AppWindow } from '../driver/window.ts';
+import { type E2eSettings } from './settings.ts';
+export { afterAll, afterEach, beforeAll, beforeEach, describe } from 'bun:test';
+export * from '../driver/index.ts';
+export { E2e, type E2eSettings } from './settings.ts';
+export interface Fixtures {
+    readonly acde: Acde;
+    readonly app: AppWindow | null;
+    readonly home: string;
+    readonly settings: E2eSettings;
+}
+export type Body = (fixtures: Fixtures) => unknown;
+export interface TestSetup {
+    readonly size?: readonly [number, number];
+    readonly localStorage?: Readonly<Record<string, string>>;
+}
+export type TestOptions = number | ({
+    readonly timeout?: number;
+} & TestSetup);
+export declare class TestTimeout extends Error {
+    constructor(message: string);
+}
+export declare class E2eRun {
+    #private;
+    static readonly MARGIN_MS = 3000;
+    static readonly GRACE_MS = 30000;
+    static readonly KEEP_MS = 15000;
+    static readonly VIDEO_MS = 5000;
+    static startTimeout(timeout: number): number;
+    static softFailures: Error[] | null;
+    static env(home: string): Record<string, string>;
+    static results(settings: E2eSettings, name: string): string;
+    static screenshots(settings: E2eSettings): string;
+    static run(name: string, body: Body, settings?: E2eSettings, timeout?: number, setup?: TestSetup, results?: string): Promise<void>;
+    static ownFrames(error: unknown, root?: string): void;
+    static within<T>(ms: number, work: () => Promise<T>, late: () => Error): Promise<T>;
+    static keep(acde: Acde | null, error: unknown, dir: string, name?: string): Promise<string>;
+}
+export declare const test: {
+    (name: string, body: Body, options?: TestOptions): void;
+    (name: string, options: TestOptions, body: Body): void;
+} & {
+    only: {
+        (name: string, body: Body, options?: TestOptions): void;
+        (name: string, options: TestOptions, body: Body): void;
+    };
+    skip: {
+        (name: string, body: Body, options?: TestOptions): void;
+        (name: string, options: TestOptions, body: Body): void;
+    };
+    todo: (name: string) => void;
+    if: (condition: boolean) => {
+        (name: string, body: Body, options?: TestOptions): void;
+        (name: string, options: TestOptions, body: Body): void;
+    };
+};
+type Asynced<M> = {
+    [K in keyof M]: M[K] extends (...args: infer A) => unknown ? (...args: A) => Promise<void> : M[K] extends object ? Asynced<M[K]> : never;
+};
+export type PollMatchers<T> = Asynced<Omit<Matchers<T>, 'resolves' | 'rejects'>>;
+export interface PollOptions {
+    readonly timeout?: number;
+    readonly message?: string;
+}
+declare function expectAny(target: Locator): LocatorAssertions;
+declare function expectAny(target: AppWindow): WindowAssertions;
+declare function expectAny<T>(value: T): Matchers<T>;
+declare function soft(target: Locator): LocatorAssertions;
+declare function soft(target: AppWindow): WindowAssertions;
+declare function soft<T>(value: T): Matchers<T>;
+export declare const expect: typeof expectAny & {
+    poll: <T>(read: () => T | Promise<T>, options?: PollOptions) => PollMatchers<Awaited<T>>;
+    soft: typeof soft;
+};

package/lib/acde/dist/types/e2e/settings.d.ts

@@ -0,0 +1,39 @@
+export interface E2eSettings {
+    readonly dirs: readonly string[];
+    readonly desktop: string | null;
+    readonly headless: boolean;
+    readonly results: string;
+    readonly file: string | null;
+    readonly timeout: number;
+    readonly trace: boolean;
+    readonly update: boolean;
+    readonly retries: number;
+    readonly video: VideoMode;
+    readonly out: string;
+}
+export type VideoMode = 'off' | 'on' | 'failed';
+export declare class E2e {
+    static readonly DIRS = "ACDE_TEST_DIRS";
+    static readonly DESKTOP = "ACDE_TEST_DESKTOP";
+    static readonly HEADLESS = "ACDE_TEST_HEADLESS";
+    static readonly RESULTS = "ACDE_TEST_RESULTS";
+    static readonly FILE = "ACDE_TEST_FILE";
+    static readonly TIMEOUT = "ACDE_TEST_TIMEOUT";
+    static readonly TRACE = "ACDE_TEST_TRACE";
+    static readonly UPDATE = "ACDE_TEST_UPDATE";
+    static readonly MARKS = "ACDE_TEST_MARKS";
+    static readonly PATTERN = "ACDE_TEST_PATTERN";
+    static readonly RETRIES = "ACDE_TEST_RETRIES";
+    static readonly VIDEO = "ACDE_TEST_VIDEO";
+    static readonly OUT = "ACDE_TEST_OUT";
+    static readonly BUILD: string;
+    static readonly TIMEOUT_MS = 60000;
+    static readonly SIZE = "1280x800";
+    static env(settings: E2eSettings): Record<string, string>;
+    static read(env?: NodeJS.ProcessEnv, cwd?: string): E2eSettings;
+    static mark(kind: 'registered' | 'ran', name: string, env?: NodeJS.ProcessEnv): void;
+    static selects(pattern: string | undefined, name: string): boolean;
+    static unselected(marks: string): boolean;
+    static project(from: string): string | null;
+    static slug(text: string): string;
+}

package/lib/acde/dist/types/ipc.d.ts

@@ -0,0 +1,24 @@
+import net from 'node:net';
+export type Message = Readonly<Record<string, unknown>>;
+export declare class Lines {
+    static read(socket: net.Socket, line: (message: Message) => void, bad?: (text: string) => void): void;
+    static write(socket: net.Socket, message: Message): void;
+}
+export declare class DevClient {
+    #private;
+    static readonly TIMEOUT_MS = 30000;
+    static readonly RETRY_MS = 50;
+    static readonly CLOSE_MS = 1000;
+    readonly closed: Promise<void>;
+    /** Events acdert sends on its own (`{ type: 'event', event, ... }`), only to the connection that said hello as acde dev. */
+    onEvent: (message: Message) => void;
+    private constructor();
+    static endpoint(pid?: number): string;
+    static prepare(endpoint: string): void;
+    static connect(endpoint: string, timeoutMs?: number): Promise<DevClient>;
+    static reach(endpoint: string, alive: () => boolean, waiting?: () => void, waitMs?: number): Promise<DevClient | null>;
+    get ended(): boolean;
+    send(message: Message): void;
+    request(op: string, args?: Readonly<Record<string, unknown>>): Promise<unknown>;
+    close(): void;
+}

package/lib/acde/dist/types/paths.d.ts

@@ -0,0 +1,5 @@
+export declare const SKIPPED: Set<string>;
+export declare const E2E_FILE: RegExp;
+export declare function contains(dir: string, path: string): boolean;
+export declare function up<T>(from: string, found: (dir: string) => T | null | undefined | false): T | null;
+export declare function slug(text: string): string;

package/lib/acde/dist/types/pm.d.ts

@@ -0,0 +1,20 @@
+export type PmName = 'bun' | 'npm' | 'pnpm' | 'yarn';
+export declare class PackageManager {
+    #private;
+    static readonly NAMES: readonly PmName[];
+    static readonly LOCKS: readonly (readonly [string, PmName])[];
+    static readonly RUNTIMES: Readonly<Record<string, PmName>>;
+    readonly name: PmName;
+    readonly at: string | null;
+    constructor(name: PmName, at?: string | null);
+    static named(name: string): PackageManager;
+    static invoking(): PackageManager;
+    static of(dir: string): PackageManager;
+    get runtime(): 'bun' | 'node';
+    version(): string | null;
+    get install(): string[];
+    run(script: string): string[];
+    exec(pkg: string, args: readonly string[]): string[];
+    static manifest(dir: string, dep: string): string | null;
+    static bin(dir: string, name: string, deps: ReadonlySet<string>): string | null;
+}

package/lib/acde/dist/types/runtime.d.ts

@@ -0,0 +1,49 @@
+import { type ChildProcess, type StdioOptions } from 'node:child_process';
+import type { Env } from './sockets.ts';
+export type { Env };
+export interface SpawnOptions {
+    readonly cwd?: string;
+    readonly env?: Env;
+    readonly stdio?: StdioOptions;
+}
+export interface Child {
+    readonly process: ChildProcess;
+    readonly pid: number;
+    readonly exited: Promise<number>;
+    readonly gone: Promise<number>;
+    kill(signal?: NodeJS.Signals): void;
+}
+export interface RuntimeProbe {
+    readonly level: number;
+    readonly said: string;
+    readonly stderr: string;
+    readonly failed: string | null;
+}
+export interface Captured {
+    readonly code: number | null;
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly error: string | null;
+    readonly timedOut: boolean;
+}
+export declare class Runtime {
+    #private;
+    static readonly bun: boolean;
+    static readonly CONDITIONS: string[];
+    static readonly KILL_MS = 5000;
+    static readonly VERSION_MS = 10000;
+    static spawn(argv: readonly string[], options?: SpawnOptions): Child;
+    static noDisplay(env?: Env, platform?: NodeJS.Platform): string | null;
+    static killTree(child: Child): void;
+    static level(acdert: string, timeout?: number): Promise<RuntimeProbe>;
+    static capture(argv: readonly string[], options: SpawnOptions & {
+        readonly timeout: number;
+    }): Promise<Captured>;
+    static readStdin(): Promise<string>;
+    static resolve(specifier: string, from: string): string;
+}
+export declare class Jsonc {
+    static parse(text: string, file?: string): unknown;
+    static strip(text: string): string;
+    static errorAt(json: string): number;
+}

package/lib/acde/dist/types/sessions.d.ts

@@ -0,0 +1,80 @@
+export interface Session {
+    readonly pid: number;
+    readonly endpoint: string;
+    readonly dirs: readonly string[];
+    readonly apps: readonly string[];
+    readonly desktop: string | null;
+    readonly headless?: boolean;
+    readonly test?: boolean;
+    readonly options?: Options;
+    readonly started: number;
+    readonly reloaded?: Reloaded;
+}
+export interface Options {
+    readonly desktop: string | null;
+    readonly app: string | null;
+}
+export interface Wanted extends Options {
+    readonly dirs: readonly string[];
+    readonly headless: boolean;
+}
+export interface Asked {
+    readonly dirs?: readonly string[] | undefined;
+    readonly desktop?: string | undefined;
+    readonly app?: string | undefined;
+    readonly headless?: boolean | undefined;
+}
+export interface Reloaded {
+    readonly console: number;
+    readonly network: number;
+}
+export declare class Sessions {
+    #private;
+    static readonly SETTLE_MS = 1000;
+    static readonly RETRY_MS = 50;
+    static readonly READS = 3;
+    static readonly PROBE_MS = 1000;
+    static readonly TEST_ENV = "ACDE_TEST_SESSION";
+    static dir(env?: NodeJS.ProcessEnv): string;
+    static file(pid: number, dir?: string): string;
+    static prepare(dir?: string): string;
+    static problem(dir?: string): string | null;
+    static socket(pid: number, dir?: string): string;
+    static write(session: Session, dir?: string): string;
+    static remove(pid: number, dir?: string): void;
+    static removeIfCurrent(session: Session, dir: string): void;
+    static alive(pid: number): boolean;
+    static sameDir(a: string, b: string): boolean;
+    static running(sessions: readonly Session[], dirs: readonly string[], self?: number): Session[];
+    static pathy(value: string): boolean;
+    static desktopProject(value: string, cwd?: string): string | null;
+    static desktopDir(value: string, cwd?: string): string | null;
+    static wanted(cwd: string, asked: Asked): Wanted;
+    static runs(session: Session, wanted: Wanted): boolean;
+    static answers(endpoint: string, timeoutMs?: number): Promise<boolean>;
+    static live(sessions: readonly Session[], dir?: string): Promise<Session[]>;
+    static list(dir?: string): Session[];
+    static scan(dir?: string): {
+        sessions: Session[];
+        busy: boolean;
+    };
+    static find(cwd: string, pid?: number, say?: (line: string) => void, dir?: string): Promise<Session>;
+    static pick(listed: readonly Session[], cwd: string, pid?: number, say?: (line: string) => void, dir?: string): Session;
+    static what(session: Session): string;
+    static describe(session: Session): string;
+}
+export interface Holder {
+    readonly pid: number;
+    readonly dir: string;
+}
+export declare class Claims {
+    #private;
+    static readonly NAME: RegExp;
+    static readonly TRIES = 20;
+    static file(project: string, dir?: string): string;
+    static beacon(pid: number, started: number, dir?: string): string;
+    static take(projects: readonly string[], started: number, dir?: string): Promise<Claims | Holder>;
+    static sweep(file: string): void;
+    private constructor();
+    release(): void;
+}

package/lib/acde/dist/types/sockets.d.ts

@@ -0,0 +1,4 @@
+export type Env = Readonly<Record<string, string | undefined>>;
+export declare const WINDOWS_PATH_MAX = 107;
+export declare function socketDir(env?: Env, platform?: string): string;
+export declare function socketPath(port: number, env?: Env, platform?: string): string;

package/lib/acde/launcher.d.mts

@@ -0,0 +1,25 @@
+export declare const NODE_MINIMUM: readonly [number, number]
+export declare const BUN_MINIMUM: readonly [number, number]
+export declare function packageRoot(): string
+export declare function runtime(): 'bun' | 'node'
+export declare function installDir(env?: Record<string, string | undefined>): string
+export declare function installed(root?: string): boolean
+export declare function which(name: string, env?: Record<string, string | undefined>): string | null
+export declare function acdertBeside(root?: string): string | null
+export interface FoundAcdert {
+  readonly path: string | null
+  readonly from: 'ACDERT' | 'install' | 'PATH' | null
+  readonly problem?: string
+}
+export declare function findAcdert(root?: string, env?: Record<string, string | undefined>): FoundAcdert
+export declare function requireAcdert(root?: string, env?: Record<string, string | undefined>): string
+export declare function atLeast(version: string, minimum: readonly [number, number]): boolean
+export declare function runtimes(env?: Record<string, string | undefined>): { bun: string | null; node: string | null }
+export declare function cliFile(root?: string): string
+export declare function cliRuntime(root?: string): string
+export declare function cliEnv(
+  exe: string,
+  env?: Record<string, string | undefined>,
+  platform?: NodeJS.Platform,
+): Record<string, string | undefined>
+export declare function run(args: readonly string[], exe?: string): Promise<number>

package/lib/acde/launcher.mjs

@@ -0,0 +1 @@
+const _0x2338a4=_0x4930;(function(_0x2ebb42,_0x5a0822){const _0x1c09dc=_0x4930,_0x4f13ec=_0x2ebb42();while(!![]){try{const _0x41b4f6=-parseInt(_0x1c09dc(0x1c0))/0x1+-parseInt(_0x1c09dc(0x1e3))/0x2+parseInt(_0x1c09dc(0x1c7))/0x3+parseInt(_0x1c09dc(0x1b8))/0x4*(-parseInt(_0x1c09dc(0x1d1))/0x5)+parseInt(_0x1c09dc(0x1b9))/0x6+parseInt(_0x1c09dc(0x1b0))/0x7*(parseInt(_0x1c09dc(0x1e1))/0x8)+parseInt(_0x1c09dc(0x1ac))/0x9*(-parseInt(_0x1c09dc(0x1cb))/0xa);if(_0x41b4f6===_0x5a0822)break;else _0x4f13ec['push'](_0x4f13ec['shift']());}catch(_0x22b5a1){_0x4f13ec['push'](_0x4f13ec['shift']());}}}(_0x1546,0xab7fb));import{spawn as _0xdbb0dd,spawnSync as _0x320ecf}from'node:child_process';import{existsSync as _0x385eb3,statSync as _0x49d6ca}from'node:fs';import{constants as _0x5a168f,homedir as _0x579671}from'node:os';function _0x1546(){const _0x44cc15=['zMLUza','u0Lhsu5u','DgvZDa','mtG5CgTXAM1d','AM9PBG','CgfJA2fNzs5QC29U','lcb3AgLJAcb0AguGywnKzsbPBNn0ywXSzxiGChv0CYb0AgvYztOGCNvUihrOzsbPBNn0ywXSzxiGywDHAw4Sia','Aw5ZDgfSBa','C3jJ','BM9Kzq','ChjVyMXLBq','ndC4ngX3weDwta','nJe1nJu4oe5zANb6zq','ls12zxjZAw9U','C2v0iefdrevsvcb0BYbHBIbHy2rLCNqGyMLUyxj5lcbVCIbWDxqGywnKzxj0ig9UifbbveG','lKnpttSUrvHfoY5cqvq7lKnnra','zw5KC1DPDgG','zxHPDa','qunervju','mtuWotGYBg9xAuXY','ywnKzsbKzxyGBMvLzhmGDgHLierVCgfTzsbYDw50Aw1LicHHy2rLCNqPigfUzcbMB3vUzcbUB25LoIa','zxjYB3i','AxngAwXL','C3rKB3v0','A2LSBa','DxrMoa','mZm1nZGWmvbjweDgzG','ywnKzwjPBI1KyMC','y2XPlMPZ','C2LNBMfSCW','nJm3nJCWqK15z2ft','ywnKzxj0','zMLSDgvY','uefusa','C3rKzxjY','yNvU','mJq4mgzLqKnwvG','Cgf0Aa','C3bSAxq','zgLZDa','ywnKzsbUzwvKCYboB2rLlMPZia','ktOGDxbKyxrLigL0icHODhrWCZOVl25VzgvQCY5VCMCP','BM8G','ywnKztOG','oIbUBYbZDwnOigzPBgu7ihbVAw50iefdrevsvcbHDcbHBIbHy2rLCNqGyMLUyxj5lcbVCIb1BNnLDcbPDa','D3jPDgu','BwfW','D2LUmZi','u0Lhvevstq','BgLI','zxHLy1bHDgG','ig9Yig5LD2vYicH0AgLZigLZia','mJC4oty4s3j6qMzU','ktOGDxbKyxrLigL0icHIDw4GDxbNCMfKzsWGB3iGAhr0Chm6lY9IDw4UC2GP','mtiZotKWnMTctxLXrW','lMv4zq','y2XPlNrZ','CgXHDgzVCM0','DMvYC2LVBNm','lMfJzgu','icHHy2rLigrVy3rVCIbJAgvJA3mGDgHLihDOB2XLihnLDhvWkq','u0Lhsfvq','Dg9vChbLCKnHC2u','ChjVy2vZCY52zxjZAw9UCY5IDw4GpYaNjYa6ihbYB2nLC3mUDMvYC2LVBNmUBM9Kzq','mtq0y3botfDv'];_0x1546=function(){return _0x44cc15;};return _0x1546();}import{basename as _0x41b54b,delimiter as _0x31833d,dirname as _0xbce53f,join as _0x2d5c7f}from'node:path';import{fileURLToPath as _0x69a970}from'node:url';var _0x38c379=_0xbce53f(_0x69a970(import.meta.url)),_0x19a68a=process[_0x2338a4(0x1e6)]===_0x2338a4(0x1dc),_0x328e37=_0x19a68a?_0x2338a4(0x1e4):'',_0xa29449=[0x16,0x3],_0x5a7c55=[0x1,0x4];function _0x3a6717(){return _0x38c379;}function _0x5640b3(){const _0x59897f=_0x2338a4;return process[_0x59897f(0x1e7)]['bun']?_0x59897f(0x1d0):_0x59897f(0x1b6);}function _0x4bf819(_0x57e6c7=process.env){const _0x9c611e=_0x2338a4;return _0x57e6c7['ACDE_INSTALL']||_0x2d5c7f(_0x579671(),_0x9c611e(0x1e8));}function _0x5672ec(_0x3b846a=_0x38c379){const _0x20f8b9=_0x2338a4;return _0x41b54b(_0xbce53f(_0x3b846a))===_0x20f8b9(0x1de)&&_0x385eb3(_0x2d5c7f(_0x3b846a,'..','acde-api',_0x20f8b9(0x1b2)));}function _0x2dd4c4(_0x3e0244,_0x237736=process.env){const _0x40e35a=_0x2338a4;let _0x434766=_0x19a68a&&!/\.[^\\/.]+$/[_0x40e35a(0x1af)](_0x3e0244)?(_0x237736['PATHEXT']||_0x40e35a(0x1bc))['split'](';')[_0x40e35a(0x1cd)](Boolean):[''];for(let _0x42ca54 of(_0x237736['PATH']||_0x237736['Path']||'')['split'](_0x31833d)){if(!_0x42ca54)continue;for(let _0x21e1e9 of _0x434766){let _0x21dbc5=_0x2d5c7f(_0x42ca54,_0x3e0244+_0x21e1e9);try{if(_0x49d6ca(_0x21dbc5)[_0x40e35a(0x1c3)]())return _0x21dbc5;}catch{}}}return null;}var _0x291999=[_0x2338a4(0x1c8),_0x2338a4(0x1cc)];function _0x35105c(_0x25e10c=_0x38c379){const _0x596684=_0x2338a4;if(!_0x5672ec(_0x25e10c))return null;let _0x230430=_0x291999[_0x596684(0x1db)](_0x4b97fd=>_0x2d5c7f(_0x25e10c,'..','..','bin',''+_0x4b97fd+_0x328e37));return _0x230430['find'](_0x16b425=>_0x385eb3(_0x16b425))??_0x230430[0x0];}function _0x34948b(_0x5576ff=_0x38c379,_0x4f359f=process.env){const _0x179749=_0x2338a4;let _0x2f81be=_0x4f359f[_0x179749(0x1bf)];if(_0x2f81be){if(_0x385eb3(_0x2f81be))return{'path':_0x2f81be,'from':_0x179749(0x1bf)};let _0x2fff5d=/[\\/]/[_0x179749(0x1af)](_0x2f81be)?null:_0x2dd4c4(_0x2f81be,_0x4f359f);if(_0x2fff5d)return{'path':_0x2fff5d,'from':_0x179749(0x1bf)};return{'path':null,'from':_0x179749(0x1bf),'problem':'ACDERT='+_0x2f81be+_0x179749(0x1d9)};}let _0x5c66ea=_0x35105c(_0x5576ff);if(_0x5c66ea&&_0x385eb3(_0x5c66ea))return{'path':_0x5c66ea,'from':_0x179749(0x1b4)};let _0x36d55a=_0x291999['map'](_0x1a5b5f=>_0x2dd4c4(''+_0x1a5b5f+_0x328e37,_0x4f359f))[_0x179749(0x1ad)](Boolean);if(_0x36d55a)return{'path':_0x36d55a,'from':_0x179749(0x1ce)};return{'path':null,'from':null,'problem':_0x179749(0x1c1)+(_0x5c66ea?_0x179749(0x1d7)+_0x5c66ea+_0x179749(0x1b3):'')+_0x179749(0x1bb)};}function _0x5b111a(_0xd0b13d=_0x38c379,_0x130b9c=process.env){const _0x5ef69f=_0x2338a4;let _0x291b3f=_0x34948b(_0xd0b13d,_0x130b9c);if(_0x291b3f[_0x5ef69f(0x1d2)])return _0x291b3f[_0x5ef69f(0x1d2)];throw Error(_0x291b3f[_0x5ef69f(0x1b7)]+_0x5ef69f(0x1a8));}function _0x362aa7(_0x78051e,_0xec4f00){const _0x5395b5=_0x2338a4;let [_0x63d7ca,_0x25efb7]=_0x78051e[_0x5395b5(0x1d3)]('.')[_0x5395b5(0x1db)](Number),[_0x85ec77,_0x194dd8]=_0xec4f00;return _0x63d7ca>_0x85ec77||_0x63d7ca===_0x85ec77&&_0x25efb7>=_0x194dd8;}function _0x17d827(_0x86fee8,_0x51a684,_0xfded0c,_0x2a612f){const _0x402816=_0x2338a4;let _0x5e7e5f=_0x2dd4c4(''+_0x86fee8+_0x328e37,_0x2a612f),_0x43adff=_0x5e7e5f?_0x320ecf(_0x5e7e5f,_0x51a684,{'encoding':_0x402816(0x1c6)}):null;return _0x43adff?.['status']===0x0&&_0x362aa7(_0x43adff[_0x402816(0x1c4)]['trim'](),_0xfded0c)?_0x5e7e5f:null;}function _0x447083(_0x3fac14=process.env){const _0x4ee3bd=_0x2338a4;if(process[_0x4ee3bd(0x1e7)][_0x4ee3bd(0x1d0)]){let _0x53166b=_0x17d827(_0x4ee3bd(0x1b6),['-p',_0x4ee3bd(0x1ab)],_0xa29449,_0x3fac14);return{'bun':process[_0x4ee3bd(0x1df)],'node':_0x53166b};}return{'bun':_0x17d827(_0x4ee3bd(0x1d0),[_0x4ee3bd(0x1ba)],_0x5a7c55,_0x3fac14),'node':process[_0x4ee3bd(0x1df)]};}function _0x54cf23(_0x46bd02=_0x38c379){const _0x599f4c=_0x2338a4;return[_0x2d5c7f(_0x46bd02,_0x599f4c(0x1d4),_0x599f4c(0x1c9)),_0x2d5c7f(_0x46bd02,_0x599f4c(0x1b5),_0x599f4c(0x1e5))]['find'](_0x3f1bb2=>_0x385eb3(_0x3f1bb2));}function _0x4854b9(_0x38bbee=_0x38c379){const _0x3a8e0a=_0x2338a4;if(process[_0x3a8e0a(0x1e7)][_0x3a8e0a(0x1d0)])return process['execPath'];if(_0x54cf23(_0x38bbee)?.[_0x3a8e0a(0x1bd)]('.ts'))return _0x2dd4c4('bun')??process[_0x3a8e0a(0x1df)];return process[_0x3a8e0a(0x1df)];}function _0x337840(_0x5a5611,_0x2793fc=process.env,_0x1e889e=process[_0x2338a4(0x1e6)]){const _0x3ff291=_0x2338a4;let _0x2dda87={..._0x2793fc},_0x133b55=_0x4ec46f=>_0x1e889e==='win32'?_0x4ec46f[_0x3ff291(0x1aa)]()===_0x3ff291(0x1ce):_0x4ec46f===_0x3ff291(0x1ce),_0x155afc=Object['keys'](_0x2dda87)[_0x3ff291(0x1cd)](_0x133b55),_0x3ed153=_0x155afc['length']>0x0?_0x2dda87[_0x155afc['at'](-0x1)]:void 0x0;for(let _0x287f42 of _0x155afc)delete _0x2dda87[_0x287f42];return{..._0x2dda87,'PATH':''+_0xbce53f(_0x5a5611)+_0x31833d+(_0x3ed153||''),'ACDE_HOST_RUNTIME':_0x2793fc['ACDE_HOST_RUNTIME']||_0x5640b3()};}function _0x55f2b6(){const _0x43f74b=_0x2338a4;if(process[_0x43f74b(0x1e7)]['bun']){if(!_0x362aa7(process['versions'][_0x43f74b(0x1d0)],_0x5a7c55))throw Error('acde\x20needs\x20Bun\x20'+_0x5a7c55[_0x43f74b(0x1b1)]('.')+_0x43f74b(0x1e0)+process['versions'][_0x43f74b(0x1d0)]+_0x43f74b(0x1e2));return;}if(!_0x362aa7(process[_0x43f74b(0x1e7)]['node'],_0xa29449))throw Error(_0x43f74b(0x1d5)+_0xa29449[_0x43f74b(0x1b1)]('.')+_0x43f74b(0x1e0)+process['version']+_0x43f74b(0x1d6));}function _0x29fa94(_0x10e48b,_0x349878=_0x4854b9()){const _0x56e47a=_0x2338a4;_0x55f2b6();let _0x46fece=_0xdbb0dd(_0x349878,[_0x54cf23(),..._0x10e48b],{'stdio':'inherit','env':_0x337840(_0x349878)});if(_0x19a68a)process['on']('SIGINT',()=>{});else{for(let _0x1b4f7b of[_0x56e47a(0x1ae),_0x56e47a(0x1dd),_0x56e47a(0x1a9)])process['on'](_0x1b4f7b,()=>_0x46fece[_0x56e47a(0x1c5)](_0x1b4f7b));}return new Promise(_0x691637=>{const _0x29456d=_0x56e47a;_0x46fece['on'](_0x29456d(0x1c2),_0x549fe8=>{const _0x3cb2a5=_0x29456d;process[_0x3cb2a5(0x1cf)][_0x3cb2a5(0x1da)](_0x3cb2a5(0x1d8)+_0x349878+':\x20'+_0x549fe8['message']+'\x0a'),_0x691637(0x1);}),_0x46fece['on'](_0x29456d(0x1be),(_0x12a57b,_0x58e0e2)=>_0x691637(_0x12a57b??0x80+(_0x5a168f[_0x29456d(0x1ca)][_0x58e0e2]??0x0)));});}function _0x4930(_0x32b5dd,_0x32a931){_0x32b5dd=_0x32b5dd-0x1a8;const _0x154646=_0x1546();let _0x4930dd=_0x154646[_0x32b5dd];if(_0x4930['YPKNsM']===undefined){var _0x4d166e=function(_0x6443c9){const _0x3ee0c3='abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/=';let _0x4fa001='',_0xdbb0dd='';for(let _0x320ecf=0x0,_0x385eb3,_0x49d6ca,_0x5a168f=0x0;_0x49d6ca=_0x6443c9['charAt'](_0x5a168f++);~_0x49d6ca&&(_0x385eb3=_0x320ecf%0x4?_0x385eb3*0x40+_0x49d6ca:_0x49d6ca,_0x320ecf++%0x4)?_0x4fa001+=String['fromCharCode'](0xff&_0x385eb3>>(-0x2*_0x320ecf&0x6)):0x0){_0x49d6ca=_0x3ee0c3['indexOf'](_0x49d6ca);}for(let _0x579671=0x0,_0x41b54b=_0x4fa001['length'];_0x579671<_0x41b54b;_0x579671++){_0xdbb0dd+='%'+('00'+_0x4fa001['charCodeAt'](_0x579671)['toString'](0x10))['slice'](-0x2);}return decodeURIComponent(_0xdbb0dd);};_0x4930['VATIev']=_0x4d166e,_0x4930['ODZjIz']={},_0x4930['YPKNsM']=!![];}const _0x204c10=_0x154646[0x0];_0x4930['ZLeRdh']!==_0x204c10&&(_0x4930['ODZjIz']={},_0x4930['ZLeRdh']=_0x204c10);const _0x513a45=_0x4930['ODZjIz'][_0x32b5dd];return _0x513a45===undefined?(_0x4930dd=_0x4930['VATIev'](_0x4930dd),_0x4930['ODZjIz'][_0x32b5dd]=_0x4930dd):_0x4930dd=_0x513a45,_0x4930dd;}export{_0x5a7c55 as BUN_MINIMUM,_0xa29449 as NODE_MINIMUM,_0x291999 as RUNTIMES,_0x35105c as acdertBeside,_0x362aa7 as atLeast,_0x337840 as cliEnv,_0x54cf23 as cliFile,_0x4854b9 as cliRuntime,_0x34948b as findAcdert,_0x4bf819 as installDir,_0x5672ec as installed,_0x3a6717 as packageRoot,_0x5b111a as requireAcdert,_0x29fa94 as run,_0x5640b3 as runtime,_0x447083 as runtimes,_0x2dd4c4 as which};

package/lib/acde/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "acde",
+  "version": "0.0.10",
+  "description": "The acde developer CLI (wrangler to acdert's workerd): acde new / check / build / install / dev. Builds a web app (any framework) or a desktop into a package acdert runs; the preload that puts an app backend's every listen on a unix socket",
+  "license": "UNLICENSED",
+  "repository": {
+    "type": "git",
+    "url": "http://gitea.dopamine/AC/acdebin-dbg",
+    "directory": "cli"
+  },
+  "type": "module",
+  "engines": {
+    "node": ">=22.3",
+    "bun": ">=1.4"
+  },
+  "exports": {
+    "./launcher": {
+      "types": "./launcher.d.mts",
+      "default": "./launcher.mjs"
+    },
+    "./driver": {
+      "types": "./dist/types/driver/index.d.ts",
+      "default": "./dist/driver/index.js"
+    },
+    "./test": {
+      "types": "./dist/types/e2e/index.d.ts",
+      "default": "./dist/e2e/index.js"
+    },
+    "./package.json": "./package.json"
+  }
+}

package/lib/acde/skills/acde/SKILL.md

@@ -0,0 +1,114 @@
+---
+name: acde
+description: Build, run, debug, and test apps and desktops for Dopame OS with the acde CLI and its runtime, acdert. Use when a project has an acde.config.jsonc, imports an acde: module (acde:fs, acde:window, ...) or depends on @dopame/acde-api, and when the user mentions acde, acdert, or Dopame OS, or asks to create, run, inspect, screenshot, drive, or end-to-end test a Dopame app or desktop.
+---
+
+# acde
+
+A Dopame OS app is a web project: HTML, CSS, and JS in any framework, optionally with a Bun or Node.js backend. `acde` is the developer CLI (create, check, build, run, inspect, test). `acdert` is the runtime that draws the desktop and the apps; `acde dev` starts it. The relation is wrangler to workerd.
+
+This skill ships inside acde and describes the version it came with. When it and the CLI disagree, the CLI is right: `acde --help` prints every command, and `acde <command> --help` that command's options.
+
+## Check the environment first
+
+Run `acde doctor`, in the project directory when there is one. It checks what follows and more (the runtime draws a test frame on the GPU), prints one line per check (`ok`, `warn`, `error` or `skip`) with a `fix:` line under each problem, and exits with code 1 on an error. Run it again whenever `acde dev`, `acde test` or the MCP `start` does not come up, before guessing. `acde doctor --fix` then fixes what acde may (the skill, `.acde/` in `.gitignore`, the sessions directory) and asks before what downloads, installs or stops something; without a terminal it skips those unless given `--yes`, which you pass only when the user agreed. Approvals, GPU drivers and the project's code it leaves to you and the user. See [Check the setup](references/guide/doctor.md).
+
+1. `acde` must be on PATH. If it is not, follow [Install](references/start/install.md).
+2. `acde dev` and `acde test` need the runtime, acdert. The acde installer sets up the acdert release that acde pairs with next to it; acde finds `ACDERT` (a path to the binary) first, then that one, then `acdert` on PATH (in the Dopame virtual machine it is already there). If `acde doctor` finds none, or one that does not run, run the acde installer again (`acde doctor --fix --yes` does that for an installed acde); only if it cannot run on this machine, offer the steps in [Install the runtime by hand](references/start/install.md#install-the-runtime-by-hand), and use them only if the user agrees. Get it from nowhere else. Without it, `acde new`, `acde check`, and `acde build` still work, and `acde dev` says what is missing.
+3. A project runs on Bun when its package manager is bun, and on Node.js with npm, pnpm, or yarn. `acde test` needs Bun.
+
+## What is not like a browser
+
+acdert has its own renderer and is not Chromium. Standard APIs follow the spec, and what the runtime lacks is absent rather than faked. Before relying on anything beyond the DOM, `fetch`, and storage, read [Web compatibility](references/reference/web.md). The mistakes to avoid:
+
+- **No modules from a CDN.** ES modules load only from the app's own files (`import('https://…')` fails): bundle every code dependency. Images, stylesheets and fonts can come from other hosts, as in a browser.
+- **Missing APIs**: Web Workers, Service Workers, `crypto.subtle`, WebGL, OffscreenCanvas, fullscreen, pointer lock. `confirm()` returns `false` and `prompt()` returns `null`; build dialogs in the page.
+- **System access goes through `acde:` modules only** (`import { fs } from 'acde:fs'`), and only for capabilities the config requests. There is no global object. Importing a module that was not requested fails. See [Capabilities](references/guide/capabilities.md).
+- **The backend has no TCP port.** A backend's `listen(port)` becomes a unix socket, and the page reaches it with a same-origin `fetch('/api/…')`. Do not `curl localhost`. See [Backend](references/guide/backend.md).
+- **Developer tools.** In 0.0.9 there are none: use the commands below to look at pages; after 0.0.9, F12 in an `acde dev` window or `acde devtools` opens the DevTools of Chrome or Edge on the page, over the Chrome DevTools Protocol. See [acde dev](references/guide/dev.md#devtools).
+- **Platforms differ.** An app that requires a capability the platform lacks does not start there; one that lists it as optional gets `null` from `load()`. See [Platform support](references/reference/platforms.md).
+
+## The working loop
+
+Create a project without prompts (`--yes` asks nothing; without it `acde new` waits for answers in a terminal):
+
+```sh
+acde new my-app --template html --label "My App" --yes
+```
+
+Run it. `acde dev` builds, starts acdert, and rebuilds and reloads on every change. It does not exit: start it in the background and keep it running while you work; `acde stop` ends it. Add `--headless` when no window is needed; pages still render and screenshots still work. It is ready when `acde webs`, run from the project directory, lists the app's page.
+
+```sh
+acde dev --headless
+```
+
+Look at what the app does, from another shell in the project directory:
+
+```sh
+acde inspect                      # the screen as text, every visible element with a ref
+acde query 'form button'          # elements by CSS selector, hidden ones too, each with a ref
+acde act w1.15 click              # act on a ref: click, type, key, drag, ...
+acde shot my-app -o shot.png      # a PNG of the app's window; read it to see the page
+acde console --level errors       # console.error and uncaught errors
+acde network --failed             # requests that failed
+acde eval my-app 'document.title' # run code in the page, print JSON
+```
+
+After a change, wait for the rebuild line in the `acde dev` output, then check `acde console --level errors` and look at the page (`acde inspect` or `acde shot`) before saying it works. A failed build prints one error line and the window keeps the last good build, so a page that did not change may mean the build failed.
+
+Write end-to-end tests in `*.e2e.ts` with the Playwright-like API from `acde/test`, and run them with `acde test`: each test gets its own isolated headless session. See [Testing](references/guide/testing.md).
+
+Before handing over: `acde check` (config and entry), `acde build` (the package in `.acde/`), and `acde test` if the project has tests.
+
+## Rules
+
+- Edit `acde.config.jsonc`, never the generated `.acde/package.json`.
+- Request a capability in the config before importing its module.
+- Declaring a capability grants it. Only the camera and the microphone ask the user, the first time a page calls `getUserMedia()`; the call waits for the answer: run `acde permissions`, then `acde allow` or `acde deny`. Answering is the user's decision, and it is kept for the app: allow only what the user asked for or agreed to, and say what you allowed. See [Capabilities](references/guide/capabilities.md#camera-and-microphone).
+- In `acde:fs` a root is an id, not a path. `"fs": true` gives the app its own folder, the root `private`: keep the app's working files there. See [Files and folders](references/guide/files.md).
+- An app that lists `services` only runs in the desktop that provides them: `acde dev` in the app project alone does not start it, `acde dev --desktop <dir>` does. See [Services](references/guide/services.md).
+- Keep `.acde/` out of git.
+- In scripts and tests, select elements by role and name (the semantic tree), not by coordinates.
+- An MCP server with the same tools is available as `acde mcp`; the CLI commands above need no setup, so prefer them unless the user has set MCP up. See [MCP](references/guide/mcp.md).
+
+## References
+
+Read the one that matches the task; each is self-contained.
+
+Getting started:
+
+- [Install](references/start/install.md): install, upgrade, uninstall, the runtime, and the Dopame desktop
+- [First app](references/start/first-app.md): from `acde new` to a capability and a build
+- [Project layout](references/start/project.md): files, config versus manifest, build output, the SDK
+
+Guides:
+
+- [Configuration](references/guide/config.md): `acde.config.jsonc` for apps and desktops
+- [Frameworks](references/guide/frameworks.md): how React, Vue, Next.js, Nuxt, SvelteKit, Astro, and others are built
+- [Assets and icons](references/guide/assets.md): `public/`, icons
+- [Backend](references/guide/backend.md): `export default { fetch }` or any server that listens
+- [Capabilities](references/guide/capabilities.md): requesting and importing `acde:` modules
+- [Windows](references/guide/window.md): `acde:window`: title, menus, closing, shortcuts
+- [Files and folders](references/guide/files.md): `acde:fs` and the file pickers
+- [Opening apps](references/guide/open.md): `acde:open`, default apps, file handlers
+- [Desktops](references/guide/desktop.md): writing a desktop instead of an app
+- [Services](references/guide/services.md): desktop services and the capabilities they provide
+- [acde dev](references/guide/dev.md): what runs, reloading, several projects, `--desktop`
+- [Check the setup](references/guide/doctor.md): `acde doctor`, what it checks, what to do about each finding, and what `--fix` repairs
+- [Debugging](references/guide/tools.md): `webs`, `eval`, `shot`, `screen`, `inspect`, `query`, `act`, `console`, `network`, `permissions`, `allow`, `deny`, `revoke`, and `devtools` (after 0.0.9)
+- [Coding agents](references/guide/agents.md): this skill, `acde skills`, where it is installed
+- [MCP](references/guide/mcp.md): `acde mcp` and its tools
+- [Testing](references/guide/testing.md): `acde test`, locators, assertions, screenshots, traces
+- [Local install](references/guide/install.md): `acde install`, `acde uninstall`, where packages are looked up
+
+Reference:
+
+- [CLI](references/reference/cli.md): every command and option
+- [acde.config.jsonc](references/reference/config.md): every config field
+- [Manifest](references/reference/manifest.md): the `acde` field of a built package
+- [acde: modules](references/reference/modules.md): signatures of every module
+- [Service API](references/reference/service.md): `ServiceFactory` and its context
+- [Testing API](references/reference/testing.md): fixtures, locators, assertions, settings
+- [Web compatibility](references/reference/web.md): storage, network, what is unsupported
+- [Environment variables](references/reference/env.md): acde, the runtime, app backends
+- [Platform support](references/reference/platforms.md): what works on macOS, Windows, Linux, and Dopame OS

package/lib/acde/skills/acde/references/guide/agents.md

@@ -0,0 +1,50 @@
+# Coding agents
+
+acde ships a **skill**: instructions and reference files that teach a coding agent (Claude Code, Codex, Cursor, Gemini CLI, and any other that reads the [Agent Skills](https://agentskills.io) format) how to create, run, inspect, and test acde projects. The skill is part of the acde archive, so it always describes the acde you have installed. These docs are generated from the same files.
+
+## Set up with one prompt
+
+Paste this into your agent:
+
+```text
+Read https://pkgs.dopame.ai/acde/install.md and follow it to set up acde on this machine.
+```
+
+It installs acde, installs the skill for the agent, and reports what is ready and what is missing.
+
+## Install the skill yourself
+
+```sh
+acde skills install
+```
+
+This links the skill into:
+
+- `~/.agents/skills/acde`, the directory shared by agents that follow the common convention (Codex, Cline, Zed, Warp, Pi, and others);
+- the skills directory of every other agent found on this machine, such as `~/.claude/skills/acde` for Claude Code or `~/.cursor/skills/acde` for Cursor.
+
+Each one is a link to the skill inside the acde install, so upgrading acde upgrades the skill.
+
+| Command | What it does |
+| --- | --- |
+| `acde skills` | Shows where the skill is installed and whether each place is current |
+| `acde skills install` | Installs it for every agent found |
+| `acde skills install --agent claude-code,cursor` | Installs it for these agents, found or not |
+| `acde skills install --dir DIR` | Installs it into `DIR/acde`; for an agent acde does not know, or a project's own skills directory such as `.agents/skills` |
+| `acde skills install --copy` | Copies instead of linking; for agents that cannot follow links. Run it again after upgrading acde |
+| `acde skills remove` | Removes it from everywhere it was installed (add `--dir DIR` for a directory you chose), and the skills directories `acde skills install` created there once they are empty |
+| `acde skills path` | Prints the directory of the skill inside the acde install |
+
+`acde skills install` never replaces a directory named `acde` that is not this skill; it stops and names it.
+
+## Agents without skills
+
+Point the agent at the skill's entry file. For example, in the project's `AGENTS.md`:
+
+```text
+This is an acde project. Before working on it, read the file SKILL.md in the directory `acde skills path` prints.
+```
+
+## What the agent can do
+
+With an `acde dev` session running, the [debugging commands](tools.md) let an agent read the screen as text, click and type, take screenshots, and read the console and network logs; [`acde test`](testing.md) runs end-to-end tests. The same tools are available over [MCP](mcp.md) for agents that prefer it.