@noego/wood 0.4.9 → 0.4.10

package/bin/axe.js

@@ -1,8 +1,12 @@
 #!/usr/bin/env node
 
+// Thin CLI adapter over @noego/wood/automation (AXE-WP-01).
+// Argument parsing and presentation only — connection, target resolution,
+// locator handling, and error classification live in typed source.
+
+import { readFile } from 'node:fs/promises';
 import path from 'node:path';
 import process from 'node:process';
-import { readFileSync } from 'node:fs';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -10,53 +14,95 @@ const __dirname = path.dirname(__filename);
 const distDir = path.resolve(__dirname, '..', 'dist');
 
 // Node's ESM loader requires file:// URLs for absolute paths on Windows;
-// raw `C:\...` strings throw ERR_UNSUPPORTED_ESM_URL_SCHEME.
-const { readWoodDevMetadata } = await import(pathToFileURL(path.join(distDir, 'dev', 'dev_metadata.js')).href);
-
-const INTERNAL_BRIDGE_KEY = '__NOEGO_WOOD_BRIDGE__';
+// raw `C:\\...` strings throw ERR_UNSUPPORTED_ESM_URL_SCHEME.
+const automation = await import(pathToFileURL(path.join(distDir, 'automation', 'index.js')).href);
 
 function printUsage() {
   console.log('Usage: axe <command> [options]');
   console.log('');
   console.log('Commands:');
-  console.log('  targets [--window <windowId>]      List attachable Wood windows');
-  console.log('  js [--window <windowId>]            Run JavaScript from stdin in the selected renderer');
-  console.log('  click <selector> [--window <id>]    Click an element');
-  console.log('  type <selector> <text> [--window <id>]  Fill an element');
-  console.log('  screenshot [path] [--window <id>]   Save a screenshot');
+  console.log('  targets                                      List attachable Wood windows');
+  console.log('  run <scenario.json> | run --stdin            Run a persistent version-1 scenario');
+  console.log('  observe [--window <id>]                      Print a JSON target/route observation');
+  console.log('  route [--window <id>]                        Print the current route or null');
+  console.log('  wait --visible <locator> [--timeout <ms>]    Wait for an element to be visible');
+  console.log('  wait --hidden <locator> [--timeout <ms>]     Wait for an element to be hidden');
+  console.log('  wait --route <page> [--timeout <ms>]         Wait for the current route');
+  console.log('  wait --url <value> [--timeout <ms>]          Wait for an exact URL');
+  console.log('  scroll [--viewport|--container <locator>] --by <dx,dy>');
+  console.log('  scroll [--viewport|--container <locator>] --to <top|bottom|left|right>');
+  console.log('  scroll [--viewport|--container <locator>] --until <locator> [--step-px <n>] [--max-steps <n>]');
+  console.log('  scroll --into-view <locator>                 Scroll an element into view');
+  console.log('  click <locator> [--then-visible <locator>] [--then-route <page>]');
+  console.log('  type <locator> <text> [--then-visible <locator>] [--then-route <page>]');
+  console.log('  fill <locator> --value <text>                Fill an element (Playwright fill semantics)');
+  console.log('  press --keys <k1,k2>                         Press one or more key chords');
+  console.log('  debug js [--window <windowId>]               Run JavaScript from stdin (explicit UI bypass; alias: js)');
+  console.log('  screenshot [path] [--window <id>]            Save a screenshot');
+  console.log('');
+  console.log('Global options: --window <windowId>  --json');
+  console.log('');
+  console.log('Locators: bare strings are CSS; prefixes select semantic locators:');
+  console.log('  test_id=<id>  role=<role>[:<name>]  label=<text>  placeholder=<text>  text=<text>  css=<selector>');
+  console.log('');
+  console.log('When multiple Wood windows are open, --window <windowId> is required.');
 }
 
+const VALUE_FLAGS = new Set([
+  '--window',
+  '--visible',
+  '--hidden',
+  '--route',
+  '--url',
+  '--timeout',
+  '--container',
+  '--by',
+  '--to',
+  '--until',
+  '--step-px',
+  '--max-steps',
+  '--into-view',
+  '--then-visible',
+  '--then-route',
+  '--keys',
+  '--value',
+]);
+
 function parseArgs(argv) {
   const positional = [];
+  const flags = new Map();
   let windowId = null;
+  let json = false;
 
   for (let i = 0; i < argv.length; i += 1) {
     const arg = argv[i];
-    if (arg === '--window') {
-      windowId = argv[i + 1] ?? null;
-      i += 1;
+    if (arg === '--json') {
+      json = true;
+      continue;
+    }
+    if (arg === '--stdin' || arg === '--viewport') {
+      flags.set(arg, true);
+      continue;
+    }
+    if (VALUE_FLAGS.has(arg)) {
+      const value = argv[i + 1];
+      if (value == null) {
+        flags.set(arg, null);
+      } else {
+        flags.set(arg, value);
+        i += 1;
+      }
+      if (arg === '--window') windowId = value ?? null;
       continue;
     }
     positional.push(arg);
   }
 
-  return { positional, windowId };
-}
-
-async function loadPlaywright() {
-  try {
-    return await import('playwright');
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`axe requires Playwright to be installed in this environment. ${message}`);
-  }
+  return { positional, flags, windowId, json };
 }
 
 async function readStdin() {
-  if (process.stdin.isTTY) {
-    return '';
-  }
-
+  if (process.stdin.isTTY) return '';
   const chunks = [];
   for await (const chunk of process.stdin) {
     chunks.push(typeof chunk === 'string' ? chunk : chunk.toString('utf8'));
@@ -64,63 +110,163 @@ async function readStdin() {
   return chunks.join('');
 }
 
-async function connectBrowser(browserUrl) {
-  const playwright = await loadPlaywright();
-  return playwright.chromium.connectOverCDP(browserUrl);
-}
-
-async function listTargets(browser) {
-  const results = [];
-  for (const context of browser.contexts()) {
-    for (const page of context.pages()) {
-      let currentWindow = null;
-      try {
-        currentWindow = await page.evaluate(async (bridgeKey) => {
-          const bridge = globalThis[bridgeKey];
-          if (!bridge || typeof bridge !== 'object') {
-            return null;
-          }
-          const windowApi = bridge.__window;
-          if (!windowApi || typeof windowApi.current !== 'function') {
-            return null;
-          }
-          return await windowApi.current();
-        }, INTERNAL_BRIDGE_KEY);
-      } catch {
-        currentWindow = null;
-      }
+function fail(error) {
+  console.error(`[axe] ${automation.describeAutomationError(error)}`);
+  process.exit(1);
+}
 
-      results.push({
-        page,
-        windowId: currentWindow?.ok ? currentWindow.windowId ?? null : null,
-        defaultRoute: currentWindow?.ok ? currentWindow.defaultRoute ?? null : null,
-        title: await page.title().catch(() => ''),
-        url: page.url(),
-      });
-    }
+function unwrap(result) {
+  if (!result.ok) fail(result.error);
+  return result.value;
+}
+
+function flagValue(flags, name) {
+  const value = flags.get(name);
+  if (typeof value !== 'string') {
+    fail({ code: 'ACTION_FAILED', message: `${name} requires a value.` });
+  }
+  return value;
+}
+
+function optionalPositiveNumber(flags, name, fallback) {
+  if (!flags.has(name)) return fallback;
+  const raw = flagValue(flags, name);
+  const value = Number(raw);
+  if (!Number.isFinite(value) || value <= 0) {
+    fail({ code: 'ACTION_FAILED', message: `${name} must be a positive number.` });
+  }
+  return value;
+}
+
+function locator(raw) {
+  return unwrap(automation.parseCliLocator(raw));
+}
+
+async function resolveTargetPage(browser, windowId) {
+  const entries = await automation.discoverTargets(browser);
+  return unwrap(automation.selectTarget(entries, windowId));
+}
+
+function printReceipt(receipt, json, human) {
+  process.stdout.write(json ? `${JSON.stringify(receipt)}\n` : `${human}\n`);
+}
+
+function postconditions(flags) {
+  const conditions = [];
+  if (flags.has('--then-route')) {
+    conditions.push({ kind: 'route', page: flagValue(flags, '--then-route') });
+  }
+  if (flags.has('--then-visible')) {
+    conditions.push({ kind: 'visible', target: locator(flagValue(flags, '--then-visible')) });
+  }
+  return conditions;
+}
+
+async function executeWithPostconditions(page, action, flags) {
+  const conditions = postconditions(flags);
+  const result = await automation.executeAction(page, action, {
+    ...(conditions[0] ? { wait: conditions[0] } : {}),
+  });
+  const receipt = unwrap(result);
+  for (const condition of conditions.slice(1)) {
+    unwrap(await automation.awaitCondition(page, condition, { timeoutMs: 5_000 }));
+  }
+  return receipt;
+}
+
+function scrollContainer(flags) {
+  if (flags.has('--container')) {
+    return { kind: 'locator', target: locator(flagValue(flags, '--container')) };
   }
-  return results;
+  return { kind: 'viewport' };
 }
 
-async function resolveTarget(browser, requestedWindowId) {
-  const targets = await listTargets(browser);
-  if (targets.length === 0) {
-    throw new Error('No renderer targets found in the running Wood app.');
+function scrollCommand(flags) {
+  if (flags.has('--into-view')) {
+    return { mode: 'into_view', target: locator(flagValue(flags, '--into-view')) };
   }
 
-  if (requestedWindowId) {
-    const match = targets.find((target) => target.windowId === requestedWindowId);
-    if (!match) {
-      throw new Error(`No Wood window target found for "${requestedWindowId}".`);
+  const container = scrollContainer(flags);
+  if (flags.has('--by')) {
+    const raw = flagValue(flags, '--by');
+    const parts = raw.split(',');
+    const deltaX = Number(parts[0]);
+    const deltaY = Number(parts[1]);
+    if (parts.length !== 2 || !Number.isFinite(deltaX) || !Number.isFinite(deltaY)) {
+      fail({ code: 'ACTION_FAILED', message: '--by must be two finite numbers formatted as dx,dy.' });
+    }
+    return { mode: 'wheel', container, deltaX, deltaY };
+  }
+  if (flags.has('--to')) {
+    const edge = flagValue(flags, '--to');
+    if (!['top', 'bottom', 'left', 'right'].includes(edge)) {
+      fail({ code: 'ACTION_FAILED', message: '--to must be top, bottom, left, or right.' });
     }
-    return match;
+    return { mode: 'position', container, edge };
+  }
+  if (flags.has('--until')) {
+    return {
+      mode: 'until',
+      container,
+      target: locator(flagValue(flags, '--until')),
+      direction: 'down',
+      stepPx: optionalPositiveNumber(flags, '--step-px', 400),
+      maxSteps: optionalPositiveNumber(flags, '--max-steps', 20),
+    };
   }
+  fail({ code: 'ACTION_FAILED', message: 'axe scroll requires exactly one of --by, --to, --until, or --into-view.' });
+}
 
-  return targets[0];
+function waitCondition(flags) {
+  const choices = ['--visible', '--hidden', '--route', '--url'].filter((name) => flags.has(name));
+  if (choices.length !== 1) {
+    fail({ code: 'ACTION_FAILED', message: 'axe wait requires exactly one of --visible, --hidden, --route, or --url.' });
+  }
+  const choice = choices[0];
+  const value = flagValue(flags, choice);
+  if (choice === '--visible' || choice === '--hidden') {
+    return { kind: choice.slice(2), target: locator(value) };
+  }
+  if (choice === '--route') return { kind: 'route', page: value };
+  return { kind: 'url', value };
+}
+
+async function runScenarioCommand(connection, positional, flags) {
+  const fromStdin = flags.has('--stdin');
+  const fileName = positional[1];
+  if (fromStdin === Boolean(fileName)) {
+    fail({ code: 'ACTION_FAILED', message: 'axe run requires exactly one scenario file or --stdin.' });
+  }
+  let source;
+  try {
+    source = fromStdin ? await readStdin() : await readFile(path.resolve(process.cwd(), fileName), 'utf8');
+  } catch (error) {
+    fail({
+      code: 'ACTION_FAILED',
+      message: 'Could not read scenario JSON.',
+      details: { cause: error instanceof Error ? error.message : String(error) },
+    });
+  }
+  let json;
+  try {
+    json = JSON.parse(source);
+  } catch (error) {
+    fail({
+      code: 'ACTION_FAILED',
+      message: 'Scenario input is not valid JSON.',
+      details: { cause: error instanceof Error ? error.message : String(error) },
+    });
+  }
+  const scenario = unwrap(automation.parseScenario(json));
+  const result = await automation.runScenario(connection, scenario, {
+    onEvent: (event) => process.stdout.write(`${JSON.stringify(event)}\n`),
+    evidenceDir: path.resolve(process.cwd(), 'axe-evidence'),
+  });
+  if (!result.ok) fail(result.error);
 }
 
 async function main() {
-  const { positional, windowId } = parseArgs(process.argv.slice(2));
+  const { positional, flags, windowId, json } = parseArgs(process.argv.slice(2));
   const command = positional[0];
 
   if (!command) {
@@ -128,57 +274,126 @@ async function main() {
     process.exit(0);
   }
 
-  const metadata = readWoodDevMetadata(process.cwd());
-  const browser = await connectBrowser(metadata.browserUrl);
+  const connection = unwrap(await automation.connectToWoodApp(process.cwd()));
 
   try {
     if (command === 'targets') {
-      const targets = await listTargets(browser);
-      const lines = targets.map((target, index) => JSON.stringify({
+      const entries = await automation.discoverTargets(connection.browser);
+      const lines = entries.map((entry, index) => JSON.stringify({
+        // index is diagnostic only — windowId/targetId are the identity contract.
         index,
-        windowId: target.windowId,
-        defaultRoute: target.defaultRoute,
-        title: target.title,
-        url: target.url,
+        targetId: entry.target.targetId,
+        windowId: entry.target.windowId,
+        defaultRoute: entry.target.configuredDefaultRoute ?? null,
+        eligible: entry.target.eligible,
+        title: entry.target.title,
+        url: entry.target.url,
       }));
       process.stdout.write(`${lines.join('\n')}\n`);
       return;
     }
 
-    const target = await resolveTarget(browser, windowId);
-    const page = target.page;
+    if (command === 'run') {
+      await runScenarioCommand(connection, positional, flags);
+      return;
+    }
+
+    const { page, target } = await resolveTargetPage(connection.browser, windowId);
+
+    if (command === 'observe') {
+      process.stdout.write(`${JSON.stringify({ target, route: target.currentRoute ?? null })}\n`);
+      return;
+    }
+
+    if (command === 'route') {
+      process.stdout.write(`${target.currentRoute ?? 'null'}\n`);
+      return;
+    }
+
+    if (command === 'wait') {
+      const condition = waitCondition(flags);
+      const timeoutMs = optionalPositiveNumber(flags, '--timeout', 5_000);
+      const waited = unwrap(await automation.awaitCondition(page, condition, { timeoutMs }));
+      process.stdout.write(json ? `${JSON.stringify(waited)}\n` : `condition satisfied after ${waited.waitedMs}ms\n`);
+      return;
+    }
+
+    if (command === 'scroll') {
+      const receipt = unwrap(await automation.executeAction(page, { kind: 'scroll', command: scrollCommand(flags) }));
+      printReceipt(receipt, json, 'scrolled');
+      return;
+    }
 
-    if (command === 'js') {
+    if (command === 'js' || (command === 'debug' && positional[1] === 'js')) {
       const source = await readStdin();
       if (!source.trim()) {
-        throw new Error('axe js expects JavaScript via stdin.');
+        fail({ code: 'ACTION_FAILED', message: 'axe debug js expects JavaScript via stdin.' });
       }
+      // Explicit diagnostic escape hatch: bypasses the real UI path (bypassedUi: true)
+      // and is excluded from release qualification scenarios.
+      process.stderr.write('[axe] debug js is a UI bypass (bypassedUi: true); not valid release-qualification evidence.\n');
       const result = await page.evaluate(async (userSource) => {
         const AsyncFunction = Object.getPrototypeOf(async function () {}).constructor;
-        return await new AsyncFunction(userSource)();
+        // Bare expressions ("2+2", "document.title") are not valid as a
+        // function *body* result — wrap them in an implicit return first;
+        // fall back to body form for statement programs ("const x = ...; return x").
+        let fn;
+        try {
+          fn = new AsyncFunction(`return (${userSource}\n);`);
+        } catch {
+          fn = new AsyncFunction(userSource);
+        }
+        return await fn();
       }, source);
       process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
       return;
     }
 
     if (command === 'click') {
-      const selector = positional[1];
-      if (!selector) {
-        throw new Error('axe click requires a selector.');
-      }
-      await page.locator(selector).click();
-      process.stdout.write(`clicked ${selector}\n`);
+      const rawLocator = positional[1];
+      if (!rawLocator) fail({ code: 'LOCATOR_INVALID', message: 'axe click requires a locator.' });
+      const targetLocator = locator(rawLocator);
+      const receipt = await executeWithPostconditions(page, { kind: 'click', target: targetLocator }, flags);
+      printReceipt(receipt, json, `clicked ${automation.describeLocator(targetLocator)}`);
       return;
     }
 
     if (command === 'type') {
-      const selector = positional[1];
+      const rawLocator = positional[1];
       const text = positional[2];
-      if (!selector || text == null) {
-        throw new Error('axe type requires a selector and text.');
+      if (!rawLocator || text == null) {
+        fail({ code: 'LOCATOR_INVALID', message: 'axe type requires a locator and text.' });
+      }
+      const targetLocator = locator(rawLocator);
+      const receipt = await executeWithPostconditions(
+        page,
+        { kind: 'type', target: targetLocator, value: text },
+        flags,
+      );
+      printReceipt(receipt, json, `typed into ${automation.describeLocator(targetLocator)}`);
+      return;
+    }
+
+    if (command === 'fill') {
+      const rawLocator = positional[1];
+      if (!rawLocator || !flags.has('--value')) {
+        fail({ code: 'LOCATOR_INVALID', message: 'axe fill requires a locator and --value <text>.' });
       }
-      await page.locator(selector).fill(text);
-      process.stdout.write(`typed into ${selector}\n`);
+      const targetLocator = locator(rawLocator);
+      const receipt = unwrap(await automation.executeAction(page, {
+        kind: 'fill',
+        target: targetLocator,
+        value: flagValue(flags, '--value'),
+      }));
+      printReceipt(receipt, json, `filled ${automation.describeLocator(targetLocator)}`);
+      return;
+    }
+
+    if (command === 'press') {
+      const keys = flagValue(flags, '--keys').split(',').map((key) => key.trim()).filter(Boolean);
+      if (keys.length === 0) fail({ code: 'ACTION_FAILED', message: '--keys must contain at least one key.' });
+      const receipt = unwrap(await automation.executeAction(page, { kind: 'press', keys }));
+      printReceipt(receipt, json, `pressed ${keys.join(', ')}`);
       return;
     }
 
@@ -191,9 +406,9 @@ async function main() {
       return;
     }
 
-    throw new Error(`Unknown axe command "${command}".`);
+    fail({ code: 'UNSUPPORTED', message: `Unknown axe command "${command}".` });
   } finally {
-    await browser.close();
+    await connection.close();
   }
 }
 

package/dist/automation/actions.cjs

@@ -0,0 +1,17 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var actions_exports = {};
+module.exports = __toCommonJS(actions_exports);
+//# sourceMappingURL=actions.cjs.map

package/dist/automation/actions.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/automation/actions.ts"],"sourcesContent":["/**\n * Canonical action model (frozen — Axe.md \"Canonical action model\").\n * Type surface only in WP-00/01; the executor lands in AXE-WP-03.\n *\n * `fill` and `type` are distinct: `fill` sets the field value through\n * Playwright's fill semantics; `type` emits keyboard input.\n */\n\nimport type { WoodLocator } from './locator.cjs';\nimport type { WoodScrollCommand } from './scrolling.cjs';\nimport type { WoodWaitCondition } from './waits.cjs';\n\nexport type WoodAutomationAction =\n  | { kind: 'click'; target: WoodLocator; button?: 'left' | 'middle' }\n  | { kind: 'double_click'; target: WoodLocator }\n  | { kind: 'fill'; target: WoodLocator; value: string }\n  | { kind: 'type'; target: WoodLocator; value: string; delayMs?: number }\n  | { kind: 'press'; target?: WoodLocator; keys: string[] }\n  | { kind: 'select'; target: WoodLocator; option: string }\n  | { kind: 'toggle'; target: WoodLocator; checked: boolean }\n  | { kind: 'scroll'; command: WoodScrollCommand }\n  | { kind: 'back' }\n  | { kind: 'forward' }\n  | { kind: 'reload' }\n  | { kind: 'wait'; condition: WoodWaitCondition };\n"],"mappings":";;;;;;;;;;;;;;AAAA;AAAA;","names":[]}

package/dist/automation/actions.d.cts

@@ -0,0 +1,57 @@
+import { WoodLocator } from './locator.cjs';
+import { WoodScrollCommand } from './scrolling.cjs';
+import { WoodWaitCondition } from './waits.cjs';
+import 'playwright';
+import './errors.cjs';
+
+/**
+ * Canonical action model (frozen — Axe.md "Canonical action model").
+ * Type surface only in WP-00/01; the executor lands in AXE-WP-03.
+ *
+ * `fill` and `type` are distinct: `fill` sets the field value through
+ * Playwright's fill semantics; `type` emits keyboard input.
+ */
+
+type WoodAutomationAction = {
+    kind: 'click';
+    target: WoodLocator;
+    button?: 'left' | 'middle';
+} | {
+    kind: 'double_click';
+    target: WoodLocator;
+} | {
+    kind: 'fill';
+    target: WoodLocator;
+    value: string;
+} | {
+    kind: 'type';
+    target: WoodLocator;
+    value: string;
+    delayMs?: number;
+} | {
+    kind: 'press';
+    target?: WoodLocator;
+    keys: string[];
+} | {
+    kind: 'select';
+    target: WoodLocator;
+    option: string;
+} | {
+    kind: 'toggle';
+    target: WoodLocator;
+    checked: boolean;
+} | {
+    kind: 'scroll';
+    command: WoodScrollCommand;
+} | {
+    kind: 'back';
+} | {
+    kind: 'forward';
+} | {
+    kind: 'reload';
+} | {
+    kind: 'wait';
+    condition: WoodWaitCondition;
+};
+
+export type { WoodAutomationAction };

package/dist/automation/actions.d.ts

@@ -0,0 +1,57 @@
+import { WoodLocator } from './locator.js';
+import { WoodScrollCommand } from './scrolling.js';
+import { WoodWaitCondition } from './waits.js';
+import 'playwright';
+import './errors.js';
+
+/**
+ * Canonical action model (frozen — Axe.md "Canonical action model").
+ * Type surface only in WP-00/01; the executor lands in AXE-WP-03.
+ *
+ * `fill` and `type` are distinct: `fill` sets the field value through
+ * Playwright's fill semantics; `type` emits keyboard input.
+ */
+
+type WoodAutomationAction = {
+    kind: 'click';
+    target: WoodLocator;
+    button?: 'left' | 'middle';
+} | {
+    kind: 'double_click';
+    target: WoodLocator;
+} | {
+    kind: 'fill';
+    target: WoodLocator;
+    value: string;
+} | {
+    kind: 'type';
+    target: WoodLocator;
+    value: string;
+    delayMs?: number;
+} | {
+    kind: 'press';
+    target?: WoodLocator;
+    keys: string[];
+} | {
+    kind: 'select';
+    target: WoodLocator;
+    option: string;
+} | {
+    kind: 'toggle';
+    target: WoodLocator;
+    checked: boolean;
+} | {
+    kind: 'scroll';
+    command: WoodScrollCommand;
+} | {
+    kind: 'back';
+} | {
+    kind: 'forward';
+} | {
+    kind: 'reload';
+} | {
+    kind: 'wait';
+    condition: WoodWaitCondition;
+};
+
+export type { WoodAutomationAction };

package/dist/automation/actions.js

@@ -0,0 +1 @@
+//# sourceMappingURL=actions.js.map

package/dist/automation/actions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}