@docsxai/engine 0.2.0

package/dist/flow-runtime.js

@@ -0,0 +1,273 @@
+// Flow-file runtime — the deterministic execution side.
+//
+// `docsxai run` translates a parsed flow-file into a sequence of browser actions, executes
+// them headlessly with zero LLM involvement, re-captures screenshots, and re-emits the doc-pack
+// artifacts (annotations, etc.). One canonical locator per step; execution halts on locator or
+// success-criterion failure — drift is a signal to recalibrate, not to absorb (no fallbacks).
+//
+// The runtime is written against a thin {@link BrowserDriver} abstraction so it's testable
+// without a real browser; the Playwright-backed driver lives in a separate module.
+import { locatorRefName } from "./flow-file.js";
+// ---------------------------------------------------------------------------
+// Errors
+// ---------------------------------------------------------------------------
+export class FlowExecutionError extends Error {
+    stepId;
+    cause;
+    constructor(message, stepId, cause) {
+        super(message);
+        this.stepId = stepId;
+        this.cause = cause;
+        this.name = "FlowExecutionError";
+    }
+}
+/**
+ * Best-effort 1-line cause extracted from a Playwright actionability log (or similar driver
+ * error). Returns undefined when nothing matches — keeps the halt message short rather than
+ * guessing. Surfaced as a `[cause]` prefix on the halt message so the agent doesn't have to
+ * scan the multi-line actionability log.
+ */
+export function inferHaltCause(rawError) {
+    const hints = [
+        [/element is disabled\b/i, "target is disabled"],
+        [/element is not enabled\b/i, "target is not enabled"],
+        [
+            /element is not visible\b/i,
+            "target is not visible (display:none / visibility:hidden / zero-sized)",
+        ],
+        [
+            /element is not attached\b/i,
+            "target was detached from the DOM (likely unmounted by an earlier action)",
+        ],
+        [/element is outside of the viewport\b/i, "target is outside the visible viewport"],
+        [/element is not stable\b/i, "target is animating / not yet stable"],
+        [/intercepts? pointer events\b/i, "target is covered by another element"],
+        [
+            /strict mode violation\b/i,
+            "selector matched multiple elements (strict-mode violation) — scope with :visible / :nth-match",
+        ],
+        [
+            /timeout .* exceeded.*waiting for/is,
+            "timeout waiting for selector — element didn't appear in time (consider raising timeout_ms or revisiting the locator)",
+        ],
+    ];
+    for (const [re, msg] of hints) {
+        if (re.test(rawError))
+            return msg;
+    }
+    const resolved = rawError.match(/locator resolved to (<[^>\n]*>)/);
+    if (resolved)
+        return `target resolved to ${resolved[1]}`;
+    return undefined;
+}
+const defaultScreenshotPath = (flow, stepId) => `docs/${flow}/screenshots/${stepId}.png`;
+/** Resolve a `target` value (`$name` ref or inline selector) using the flow-file's locators (or a custom resolver). */
+export function resolveTarget(value, flow, resolver) {
+    const name = locatorRefName(value);
+    if (!name)
+        return value; // inline selector
+    const resolved = (resolver ?? ((n) => flow.locators[n]))(name);
+    if (resolved === undefined) {
+        throw new Error(`unresolved locator $${name}`);
+    }
+    return resolved;
+}
+async function applyWait(driver, wait, resolve) {
+    if (typeof wait === "string") {
+        if (wait === "network_idle")
+            return driver.waitForNetworkIdle();
+        if (wait === "load")
+            return driver.waitForLoad();
+        // element_stable without a selector is a no-op signal in this prototype; a real driver may track layout.
+        return;
+    }
+    if ("selector" in wait)
+        return driver.waitForSelector(resolve(wait.selector), wait.timeout_ms);
+    if ("timeout_ms" in wait)
+        return driver.waitForTimeout(wait.timeout_ms);
+}
+async function checkSuccess(driver, success, resolve, stepId) {
+    const at = async () => `at ${await driver.currentUrl().catch(() => "?")}`;
+    if ("visible" in success) {
+        const sel = resolve(success.visible);
+        if (!(await driver.isVisible(sel))) {
+            throw new FlowExecutionError(`expected ${success.visible} to be visible — ${await at()}; ${await driver.count(sel).catch(() => "?")} element(s) match the selector`, stepId);
+        }
+        return;
+    }
+    if ("hidden" in success) {
+        const sel = resolve(success.hidden);
+        if (await driver.isVisible(sel)) {
+            throw new FlowExecutionError(`expected ${success.hidden} to be hidden but a match is visible — ${await at()}; ${await driver.count(sel).catch(() => "?")} element(s) match`, stepId);
+        }
+        return;
+    }
+    if ("url_matches" in success) {
+        if (!(await driver.urlMatches(success.url_matches))) {
+            throw new FlowExecutionError(`expected URL to match /${success.url_matches}/ — actual: ${await driver.currentUrl().catch(() => "?")}`, stepId);
+        }
+        return;
+    }
+    if ("text_contains" in success) {
+        const { selector, text } = success.text_contains;
+        const sel = resolve(selector);
+        if (!(await driver.textContains(sel, text))) {
+            const actual = ((await driver.textOf(sel).catch(() => null)) ?? "")
+                .replace(/\s+/g, " ")
+                .trim()
+                .slice(0, 200);
+            throw new FlowExecutionError(`expected ${selector} to contain ${JSON.stringify(text)} — ${await at()}; actual text: ${JSON.stringify(actual)}`, stepId);
+        }
+    }
+}
+async function executeAction(driver, step, selector) {
+    switch (step.action) {
+        case "navigate":
+            if (!step.value)
+                throw new FlowExecutionError("navigate requires `value` (path/URL)", step.id);
+            return driver.goto(step.value);
+        case "click":
+            return driver.click(needSelector(selector, step));
+        case "fill":
+            if (step.value === undefined)
+                throw new FlowExecutionError("fill requires `value`", step.id);
+            return driver.fill(needSelector(selector, step), step.value);
+        case "upload":
+            if (step.value === undefined)
+                throw new FlowExecutionError("upload requires `value` (file path)", step.id);
+            return driver.upload(needSelector(selector, step), step.value);
+        case "press":
+            if (!step.value)
+                throw new FlowExecutionError("press requires `value` (key)", step.id);
+            return driver.press(selector, step.value);
+        case "hover":
+            return driver.hover(needSelector(selector, step));
+        case "select":
+            if (step.value === undefined)
+                throw new FlowExecutionError("select requires `value` (option)", step.id);
+            return driver.selectOption(needSelector(selector, step), step.value);
+        case "check":
+            return driver.setChecked(needSelector(selector, step), true);
+        case "uncheck":
+            return driver.setChecked(needSelector(selector, step), false);
+        case "wait":
+            return; // a bare `wait` step just runs its `wait_for`
+    }
+}
+function needSelector(selector, step) {
+    if (selector === null)
+        throw new FlowExecutionError(`action "${step.action}" requires a \`target\``, step.id);
+    return selector;
+}
+/**
+ * Execute a flow-file against a {@link BrowserDriver}, re-capturing screenshots and emitting annotation records.
+ * Deterministic: given the same site state and driver behaviour, produces the same result. Halts on the first
+ * locator / success-criterion failure.
+ */
+export async function runFlow(flow, driver, opts = {}) {
+    const captureDocs = opts.captureDocs ?? true;
+    const screenshotPathOf = opts.screenshotPath ?? defaultScreenshotPath;
+    const resolve = (v) => resolveTarget(v, flow, opts.resolveLocator);
+    const executed = [];
+    const annotations = [];
+    // startFrom validation: if set, must name an actual step id in this (already-merged) flow.
+    // Catching the typo here is cheaper than running, halting, and reading the wall of Playwright noise.
+    if (opts.startFrom && !flow.steps.some((s) => s.id === opts.startFrom)) {
+        throw new Error(`startFrom: no step with id "${opts.startFrom}" in flow "${flow.name}"`);
+    }
+    let skipping = !!opts.startFrom;
+    // Flow-level redactions apply to every screenshot; per-step ones are additive. Resolved up
+    // front (locator refs → selectors, default style applied) so halt shots get them too.
+    const redactionsFor = (step) => [...(flow.redactions ?? []), ...(step.redactions ?? [])].map((r) => "selector" in r
+        ? { selector: resolve(r.selector), style: r.style ?? "box" }
+        : { region: r.region, style: r.style ?? "box" });
+    for (const step of flow.steps) {
+        if (skipping) {
+            if (step.id === opts.startFrom)
+                skipping = false;
+            else
+                continue;
+        }
+        const selector = step.target ? resolve(step.target) : null;
+        const redactions = redactionsFor(step);
+        try {
+            await executeAction(driver, step, selector);
+            if (step.wait_for) {
+                if (step.wait_for === "element_stable" && selector)
+                    await driver.waitForElementStable(selector);
+                else
+                    await applyWait(driver, step.wait_for, resolve);
+            }
+            if (step.success)
+                await checkSuccess(driver, step.success, resolve, step.id);
+        }
+        catch (e) {
+            // Optional step (conditionally-present UI): swallow the failure, log it, move on.
+            // No screenshot / annotation for a skipped step — same as a `--start-from`-skipped one.
+            if (step.optional) {
+                process.stderr.write(`runFlow: optional step "${step.id}" (${step.action}) skipped — ${e.message}\n`);
+                continue;
+            }
+            // Halt: dump a screenshot for triage (best-effort), prepend a 1-line inferred cause
+            // (parsed from Playwright's actionability log so the agent doesn't have to scan ~20 lines
+            //  to know why), then surface step id + url + halt-shot path uniformly.
+            const haltShot = `docs/${flow.name}/halts/${step.id}.png`;
+            // Halt shots can capture the same sensitive UI as step shots — same redactions apply.
+            if (captureDocs)
+                await driver.screenshot(haltShot, redactions).catch(() => undefined);
+            const suffix = captureDocs ? ` (halt screenshot: ${haltShot})` : "";
+            const cause = inferHaltCause(e.message ?? "");
+            const causePrefix = cause ? `[${cause}] ` : "";
+            if (e instanceof FlowExecutionError) {
+                throw new FlowExecutionError(`${causePrefix}${e.message}${suffix}`, e.stepId, e.cause);
+            }
+            const where = await driver.currentUrl().catch(() => "?");
+            throw new FlowExecutionError(`${causePrefix}step "${step.id}" (${step.action}) failed at ${where}: ${e.message}${suffix}`, step.id, e);
+        }
+        const ex = {
+            id: step.id,
+            action: step.action,
+            ...(selector ? { selector } : {}),
+        };
+        // Doc capture is best-effort. When a step's action *transitions the UI* the action target is often
+        // unmounted by the time we capture — `boundingBox` would hang for the driver's default 30s. Short
+        // timeout + try/catch → continue with no annotation for this step. `annotation.target` (if set)
+        // overrides the anchor — point the halo at a different element that *does* exist in the new state.
+        // A step can also have `annotations: [...]` to put multiple numbered call-outs on the same screenshot —
+        // each becomes one record with a 1-based `index`; an `annotation` (singular) emits one record without
+        // `index` (un-numbered, back-compat).
+        const anns = step.annotations ?? (step.annotation ? [step.annotation] : []);
+        if (captureDocs && anns.length > 0) {
+            try {
+                const shot = screenshotPathOf(flow.name, step.id);
+                await driver.screenshot(shot, redactions);
+                ex.screenshot = shot;
+                for (let i = 0; i < anns.length; i++) {
+                    const ann = anns[i];
+                    const annSelector = ann.target ? resolve(ann.target) : selector;
+                    const bbox = annSelector ? await driver.boundingBox(annSelector, 2000) : null;
+                    annotations.push({
+                        step: step.id,
+                        selector: annSelector ?? "",
+                        ...(bbox ? { bounding_box: bbox } : {}),
+                        copy: ann.copy,
+                        ...(ann.arrow ? { arrow_style: ann.arrow } : {}),
+                        ...(ann.nudge ? { nudge: ann.nudge } : {}),
+                        ...(anns.length > 1 ? { index: i + 1 } : {}),
+                    });
+                }
+            }
+            catch (e) {
+                process.stderr.write(`runFlow: step "${step.id}" — annotation capture skipped (${e.message})\n`);
+            }
+        }
+        executed.push(ex);
+        if (opts.stopAfter && step.id === opts.stopAfter)
+            break;
+    }
+    return {
+        flow: flow.name,
+        steps: executed,
+        annotations: { schema: "docsxai/annotations@1", flow: flow.name, annotations },
+    };
+}

package/dist/flow-tree.d.ts

@@ -0,0 +1,19 @@
+import type { FlowFile } from "./doc-pack.js";
+export type FlowTreeNode = {
+    name: string;
+    steps: number;
+    children: FlowTreeNode[];
+};
+export type FlowTreeIssue = {
+    flow: string;
+    message: string;
+};
+export type FlowTreeResult = {
+    roots: FlowTreeNode[];
+    /** Flows whose `extends` target isn't in the workspace. Listed separately so they're visible. */
+    orphans: FlowTreeNode[];
+    /** Resolution-time errors (cycles, step-id collisions across the merge, missing extends targets). */
+    issues: FlowTreeIssue[];
+};
+export declare function buildFlowTree(flowsByName: Map<string, FlowFile>): Promise<FlowTreeResult>;
+export declare function formatTreeText(result: FlowTreeResult): string;

package/dist/flow-tree.js

@@ -0,0 +1,104 @@
+// Visualise the `extends` graph across a workspace's flow-files; report step-id collisions
+// across the merged step list. Pure-static — no Playwright, no live page. Run via `docsxai flow-tree`.
+import { resolveFlowExtends } from "./flow-file.js";
+export async function buildFlowTree(flowsByName) {
+    const childrenOf = new Map();
+    const orphanNames = [];
+    const rootNames = [];
+    for (const [name, flow] of flowsByName) {
+        if (!flow.extends) {
+            rootNames.push(name);
+        }
+        else if (!flowsByName.has(flow.extends)) {
+            orphanNames.push(name);
+        }
+        else {
+            const list = childrenOf.get(flow.extends) ?? [];
+            list.push(name);
+            childrenOf.set(flow.extends, list);
+        }
+    }
+    const build = (name) => {
+        const flow = flowsByName.get(name);
+        const kids = (childrenOf.get(name) ?? []).slice().sort().map(build);
+        return { name, steps: flow.steps.length, children: kids };
+    };
+    const issues = [];
+    const loadFlow = (n) => {
+        const f = flowsByName.get(n);
+        if (!f)
+            throw new Error(`extends target not found: ${n}`);
+        return f;
+    };
+    for (const [name, flow] of flowsByName) {
+        if (!flow.extends || orphanNames.includes(name))
+            continue;
+        try {
+            await resolveFlowExtends(flow, loadFlow);
+        }
+        catch (e) {
+            issues.push({ flow: name, message: e.message });
+        }
+    }
+    return {
+        roots: rootNames.slice().sort().map(build),
+        orphans: orphanNames.slice().sort().map(build),
+        issues,
+    };
+}
+export function formatTreeText(result) {
+    let out = "";
+    for (const root of result.roots) {
+        out += renderRoot(root);
+        out += "\n";
+    }
+    if (result.orphans.length) {
+        out += "(extends parent not in workspace — orphan flows)\n";
+        for (const o of result.orphans)
+            out += renderRoot(o);
+        out += "\n";
+    }
+    const total = countTotal(result);
+    const maxDepth = Math.max(0, ...result.roots.map(depth), ...result.orphans.map(depth));
+    out += `${total} flow${total !== 1 ? "s" : ""}, max chain depth ${maxDepth}\n`;
+    if (result.issues.length) {
+        out += "\nissues:\n";
+        for (const i of result.issues)
+            out += `  ${i.flow}: ${i.message}\n`;
+    }
+    return out;
+}
+function renderRoot(node) {
+    let out = `${node.name}    [${node.steps} step${node.steps !== 1 ? "s" : ""}]\n`;
+    for (let i = 0; i < node.children.length; i++) {
+        out += renderChild(node.children[i], "", i === node.children.length - 1);
+    }
+    return out;
+}
+function renderChild(node, parentPrefix, isLast) {
+    const connector = isLast ? "└── " : "├── ";
+    let out = `${parentPrefix}${connector}${node.name}    [+${node.steps} step${node.steps !== 1 ? "s" : ""}]\n`;
+    const childPrefix = parentPrefix + (isLast ? "    " : "│   ");
+    for (let i = 0; i < node.children.length; i++) {
+        out += renderChild(node.children[i], childPrefix, i === node.children.length - 1);
+    }
+    return out;
+}
+function countTotal(result) {
+    let n = 0;
+    const walk = (node) => {
+        n++;
+        for (const c of node.children)
+            walk(c);
+    };
+    for (const r of result.roots)
+        walk(r);
+    for (const o of result.orphans)
+        walk(o);
+    return n;
+}
+function depth(node) {
+    if (node.children.length === 0)
+        return 1;
+    return 1 + Math.max(...node.children.map(depth));
+}

package/dist/index.d.ts

@@ -0,0 +1,27 @@
+export declare const name = "@docsxai/engine";
+export * from "./doc-pack.js";
+export * from "./doc-pack-io.js";
+export * from "./flow-file.js";
+export * from "./flow-runtime.js";
+export * from "./flow-lint.js";
+export * from "./flow-tree.js";
+export * from "./auth.js";
+export * from "./backend-client.js";
+export * from "./calibrate.js";
+export * from "./diagnose.js";
+export * from "./doctor.js";
+export * from "./playwright-driver.js";
+export * from "./playwright-instrumented-browser.js";
+export * from "./style.js";
+export * from "./workspace.js";
+export * from "./zip.js";
+export * from "./plugins/types.js";
+export * from "./plugins/manifest.js";
+export * from "./plugins/registry.js";
+export * from "./plugins/runtime.js";
+export * from "./plugins/lock.js";
+export * from "./redact.js";
+export * from "./viewer-bin.js";
+export * from "./export/adf.js";
+export * from "./export/playwright-test.js";
+export * from "./diff.js";

package/dist/index.js

@@ -0,0 +1,31 @@
+// @docsxai/engine
+// LLM-agnostic engine: flow-file parser + deterministic runtime + the target-site auth-strategy
+// layer + calibration-aid helpers (lint, diagnose, flow-tree, style) + doc-pack IO, the backend
+// client, and the zip hand-off packager.
+export const name = "@docsxai/engine";
+export * from "./doc-pack.js";
+export * from "./doc-pack-io.js";
+export * from "./flow-file.js";
+export * from "./flow-runtime.js";
+export * from "./flow-lint.js";
+export * from "./flow-tree.js";
+export * from "./auth.js";
+export * from "./backend-client.js";
+export * from "./calibrate.js";
+export * from "./diagnose.js";
+export * from "./doctor.js";
+export * from "./playwright-driver.js";
+export * from "./playwright-instrumented-browser.js";
+export * from "./style.js";
+export * from "./workspace.js";
+export * from "./zip.js";
+export * from "./plugins/types.js";
+export * from "./plugins/manifest.js";
+export * from "./plugins/registry.js";
+export * from "./plugins/runtime.js";
+export * from "./plugins/lock.js";
+export * from "./redact.js";
+export * from "./viewer-bin.js";
+export * from "./export/adf.js";
+export * from "./export/playwright-test.js";
+export * from "./diff.js";

package/dist/playwright-driver.d.ts

@@ -0,0 +1,105 @@
+import { type Browser, type BrowserContext, type Page } from "playwright-core";
+import { type BoundingBox, type EnvironmentSpec, type ViewportSize } from "./doc-pack.js";
+import { type ActionableState, type BrowserDriver, type ResolvedRedaction } from "./flow-runtime.js";
+import { type StorageState } from "./auth.js";
+/**
+ * The cached Chromium binary path, or `undefined` when `playwright-core` has none installed.
+ *
+ * This is the single sanctioned entry point to `chromium.executablePath()`: keeping the
+ * availability probe here (the one module allowed to static-import playwright-core) means callers
+ * like `docsxai doctor` can ask "is a browser present?" without opening a second playwright-core
+ * import site. `executablePath()` only reports where the binary *would* live, so we existsSync it.
+ */
+export declare function chromiumExecutablePath(): string | undefined;
+/**
+ * Transparent pass-through to `browser.newContext` for auth mechanisms the engine doesn't model
+ * itself (HTTP basic, mTLS client certs, static header tokens). The shapes mirror Playwright's
+ * context options; the engine never inspects them.
+ */
+export interface SessionContextOptions {
+    httpCredentials?: {
+        username: string;
+        password: string;
+    };
+    clientCertificates?: unknown[];
+    extraHTTPHeaders?: Record<string, string>;
+}
+export interface PlaywrightSessionOptions {
+    /** Base URL for relative `goto` paths. */
+    baseURL?: string;
+    /** Captured session to seed the context with (from a calibration capture / the auth strategy). */
+    storageState?: StorageState;
+    /** Run headed (useful for `manual-capture` and debugging). Default: headless. */
+    headed?: boolean;
+    /** Accept self-signed / invalid TLS certs (e.g. an app's local HTTPS dev cert). Default: false. */
+    ignoreHTTPSErrors?: boolean;
+    /** Extra Chromium args (e.g. the security-lowered flags `manual-capture` uses). */
+    chromiumArgs?: string[];
+    /** Doc-pack root that screenshot paths are resolved against. */
+    docPackRoot?: string;
+    /** If set, attach to a running Chrome at this CDP endpoint (e.g. `http://localhost:9222`) instead of launching one. `close()` won't close it. */
+    connectOverCdp?: string;
+    /**
+     * Deterministic execution environment (a flow-file's resolved `environment` block). Locale /
+     * timezone / viewport / color-scheme / reduced-motion are context options; the clock is frozen
+     * via Playwright's clock API on the session's page. With `connectOverCdp` the context is
+     * externally owned — only the clock applies; the rest is skipped with one stderr warning.
+     */
+    environment?: EnvironmentSpec;
+    /** Extra `browser.newContext` options — see {@link SessionContextOptions}. Ignored with `connectOverCdp`. */
+    contextOptions?: SessionContextOptions;
+}
+/** Map an {@link EnvironmentSpec} to the Playwright context options it pins (clock excluded — that's a page-level install). */
+export declare function environmentContextOptions(env: EnvironmentSpec): {
+    locale?: string;
+    timezoneId?: string;
+    viewport?: ViewportSize;
+    colorScheme?: "light" | "dark";
+    reducedMotion?: "reduce" | "no-preference";
+};
+/** A launched Playwright browser + context + page, plus the driver bound to it. Call `close()` when done. */
+export interface PlaywrightSession {
+    browser: Browser;
+    context: BrowserContext;
+    page: Page;
+    driver: BrowserDriver;
+    /** Snapshot the context's `storageState` (cookies + localStorage + sessionStorage). */
+    storageState(): Promise<StorageState>;
+    close(): Promise<void>;
+}
+/** Launch Chromium (or, with `connectOverCdp`, attach to a running one) and return a {@link PlaywrightSession}. */
+export declare function launchPlaywrightSession(opts?: PlaywrightSessionOptions): Promise<PlaywrightSession>;
+export declare class PlaywrightDriver implements BrowserDriver {
+    private readonly page;
+    private readonly docPackRoot;
+    constructor(page: Page, docPackRoot?: string);
+    goto(url: string): Promise<void>;
+    click(selector: string): Promise<void>;
+    fill(selector: string, value: string): Promise<void>;
+    upload(selector: string, filePath: string): Promise<void>;
+    press(selector: string | null, key: string): Promise<void>;
+    hover(selector: string): Promise<void>;
+    selectOption(selector: string, value: string): Promise<void>;
+    setChecked(selector: string, checked: boolean): Promise<void>;
+    waitForNetworkIdle(): Promise<void>;
+    waitForLoad(): Promise<void>;
+    waitForElementStable(selector: string): Promise<void>;
+    waitForSelector(selector: string, timeoutMs?: number): Promise<void>;
+    waitForTimeout(ms: number): Promise<void>;
+    isVisible(selector: string): Promise<boolean>;
+    urlMatches(pattern: string): Promise<boolean>;
+    textContains(selector: string, text: string): Promise<boolean>;
+    currentUrl(): Promise<string>;
+    count(selector: string): Promise<number>;
+    textOf(selector: string): Promise<string | null>;
+    boundingBox(selector: string, timeoutMs?: number): Promise<BoundingBox | null>;
+    screenshot(relPath: string, redactions?: ResolvedRedaction[]): Promise<void>;
+    /**
+     * Resolve redactions to pixel rects in the screenshot's device-pixel space: selector entries via
+     * {@link boundingBox} (already dpr-scaled), fixed regions scaled by the page's devicePixelRatio.
+     * A selector matching nothing on-page is skipped with a warning — an absent element is vacuously
+     * redacted; halting would punish flows for UI that legitimately isn't there.
+     */
+    private resolveRedactionBoxes;
+    actionable(selector: string, timeoutMs?: number): Promise<ActionableState>;
+}