opensteer 0.6.12 → 0.7.0

package/dist/index.js

@@ -1,406 +1,470 @@
-import {
-  BrowserProfileClient
-} from "./chunk-ZRCFF546.js";
-import {
-  ActionWsClient,
-  BrowserPool,
-  CounterResolutionError,
-  CursorController,
-  ElementPathError,
-  LocalSelectorStorage,
-  OPENSTEER_HIDDEN_ATTR,
-  OPENSTEER_INTERACTIVE_ATTR,
-  OPENSTEER_SCROLLABLE_ATTR,
-  OS_BOUNDARY_ATTR,
-  OS_IFRAME_BOUNDARY_TAG,
-  OS_NODE_ID_ATTR,
-  OS_SHADOW_BOUNDARY_TAG,
-  OS_UNAVAILABLE_ATTR,
-  Opensteer,
-  OpensteerActionError,
-  OpensteerAgentActionError,
-  OpensteerAgentApiError,
-  OpensteerAgentBusyError,
-  OpensteerAgentConfigError,
-  OpensteerAgentError,
-  OpensteerAgentExecutionError,
-  OpensteerAgentProviderError,
-  OpensteerCuaAgentHandler,
-  SvgCursorRenderer,
-  buildArrayFieldPathCandidates,
-  buildElementPathFromHandle,
-  buildElementPathFromSelector,
-  buildPathSelectorHint,
-  cleanForAction,
-  cleanForClickable,
-  cleanForExtraction,
-  cleanForFull,
-  cleanForScrollable,
-  clearCookies,
-  clearPersistentProfileSingletons,
-  cloneElementPath,
-  closeTab,
-  collectLocalSelectorCacheEntries,
-  countArrayItemsWithPath,
-  createCuaClient,
-  createEmptyRegistry,
-  createIsolatedRuntimeProfile,
-  createTab,
-  exportCookies,
-  extractArrayRowsWithPaths,
-  extractArrayWithPaths,
-  extractWithPaths,
-  getCookies,
-  getElementAttributes,
-  getElementBoundingBox,
-  getElementText,
-  getElementValue,
-  getOrCreatePersistentProfile,
-  getPageHtml,
-  getPageTitle,
-  importCookies,
-  listTabs,
-  markInteractiveElements,
-  performClick,
-  performFileUpload,
-  performHover,
-  performInput,
-  performScroll,
-  performSelect,
-  persistIsolatedRuntimeProfile,
-  planSnappyCursorMotion,
-  prepareSnapshot,
-  pressKey,
-  queryAllByElementPath,
-  resolveAgentConfig,
-  resolveCounterElement,
-  resolveCountersBatch,
-  resolveElementPath,
-  sanitizeElementPath,
-  serializePageHTML,
-  setCookie,
-  switchTab,
-  typeText,
-  waitForVisualStability
-} from "./chunk-RC4IPQDZ.js";
-import {
-  CloudCdpClient,
-  CloudSessionClient,
-  OpensteerCloudError,
-  cloudActionMethods,
-  cloudErrorCodes,
-  cloudNotLaunchedError,
-  cloudSessionContractVersion,
-  cloudSessionSourceTypes,
-  cloudSessionStatuses,
-  cloudUnsupportedMethodError,
-  isCloudActionMethod,
-  isCloudErrorCode,
-  isCloudSessionSourceType,
-  isCloudSessionStatus,
-  normalizeNamespace,
-  resolveNamespaceDir
-} from "./chunk-2ES46WCO.js";
-import {
-  detectChromePaths,
-  expandHome,
-  listLocalChromeProfiles
-} from "./chunk-K5CL76MG.js";
-import {
-  createResolveCallback
-} from "./chunk-DN3GI5CH.js";
-import {
-  createExtractCallback
-} from "./chunk-AVXUMEDG.js";
-import "./chunk-3H5RRIMZ.js";
-import {
-  getModelProvider
-} from "./chunk-FAHE5DB2.js";
+import { createOpensteerSemanticRuntime, AttachedOpensteerSessionProxy, OpensteerSessionRuntime } from './chunk-PQYA6IX2.js';
+export { CloudSessionProxy, DEFERRED_MATCH_ATTR_KEYS, ElementPathError, MATCH_ATTRIBUTE_PRIORITY, OPENSTEER_DOM_ACTION_BRIDGE_SYMBOL, OPENSTEER_FILESYSTEM_ROOT_LAYOUT, OPENSTEER_FILESYSTEM_ROOT_VERSION, OpensteerAttachAmbiguousError, OpensteerCloudClient, OpensteerLocalProfileUnavailableError, OpensteerSessionRuntime, STABLE_PRIMARY_ATTR_KEYS, ServiceOperationScheduler, buildArrayFieldPathCandidates, buildPathCandidates, buildPathSelectorHint, buildSegmentSelector, cloneElementPath, cloneReplayElementPath, cloneStructuralElementAnchor, createDomRuntime, createFilesystemOpensteerRoot, defaultFallbackPolicy, defaultPolicy, defaultRetryPolicy, defaultSettlePolicy, defaultTimeoutPolicy, delayWithSignal, detectInstalledBrowserBrands, discoverLocalCdpBrowsers, dispatchSemanticOperation, generateStealthInitScript, generateStealthProfile, getAllBrowserBrands, getBrowserBrand, inspectCdpEndpoint, inspectLocalBrowserProfile, isCurrentUrlField, isValidCssAttributeKey, listLocalChromeProfiles, normalizeExtractedValue, normalizeOpensteerExecutionMode, parseRequestEnvelope, resolveCloudConfig, resolveCookieCaptureStrategy, resolveDomActionBridge, resolveExtractedValueInContext, resolveOpensteerExecutionMode, runWithPolicyTimeout, sanitizeElementPath, sanitizeReplayElementPath, sanitizeStructuralElementAnchor, settleWithPolicy, shouldKeepAttributeForPath, unlockLocalBrowserProfile } from './chunk-PQYA6IX2.js';
 
-// src/cursor/renderers/cdp-overlay.ts
-var PULSE_DELAY_MS = 30;
-var CdpOverlayCursorRenderer = class {
-  page = null;
-  session = null;
-  active = false;
-  reason = "disabled";
-  lastMessage;
-  lastPoint = null;
-  async initialize(page) {
-    this.page = page;
-    if (page.isClosed()) {
-      this.markInactive("page_closed");
-      return;
+// src/sdk/opensteer.ts
+var Opensteer = class _Opensteer {
+  runtime;
+  ownership;
+  constructor(options = {}) {
+    this.runtime = createOpensteerSemanticRuntime({
+      runtimeOptions: options,
+      ...options.cloud === void 0 ? {} : { cloud: options.cloud }
+    });
+    this.ownership = "owned";
+  }
+  static attach(options = {}) {
+    return _Opensteer.fromRuntime(
+      new AttachedOpensteerSessionProxy({
+        ...options.name === void 0 ? {} : { name: options.name },
+        ...options.rootDir === void 0 ? {} : { rootDir: options.rootDir }
+      }),
+      "attached"
+    );
+  }
+  async open(input = {}) {
+    const normalized = typeof input === "string" ? { url: input } : input;
+    if (this.ownership === "attached") {
+      assertAttachedOpenInputAllowed(normalized);
     }
-    await this.createSession();
+    return this.runtime.open(normalized);
   }
-  isActive() {
-    return this.active;
+  async listPages(input = {}) {
+    return this.runtime.listPages(input);
   }
-  status() {
-    return {
-      enabled: true,
-      active: this.active,
-      reason: this.reason ? this.lastMessage ? `${this.reason}: ${this.lastMessage}` : this.reason : void 0
-    };
+  async newPage(input = {}) {
+    return this.runtime.newPage(input);
   }
-  async move(point, style) {
-    await this.sendWithRecovery(async (session) => {
-      await session.send("Overlay.highlightQuad", {
-        quad: buildCursorQuad(point, style.size),
-        color: toProtocolRgba(style.fillColor),
-        outlineColor: toProtocolRgba(style.outlineColor)
-      });
+  async activatePage(input) {
+    return this.runtime.activatePage(input);
+  }
+  async closePage(input = {}) {
+    return this.runtime.closePage(input);
+  }
+  async goto(input) {
+    return this.runtime.goto(typeof input === "string" ? { url: input } : input);
+  }
+  async evaluate(input) {
+    const normalized = typeof input === "string" ? {
+      script: input
+    } : input;
+    const result = await this.runtime.evaluate(normalized);
+    return result.value;
+  }
+  async evaluateJson(input) {
+    return this.evaluate(input);
+  }
+  async addInitScript(input) {
+    const normalized = typeof input === "string" ? {
+      script: input
+    } : input;
+    return this.runtime.addInitScript(normalized);
+  }
+  async snapshot(input = {}) {
+    const mode = typeof input === "string" ? input : input.mode;
+    return this.runtime.snapshot(mode === void 0 ? {} : { mode });
+  }
+  async click(input) {
+    const normalized = normalizeTargetOptions(input);
+    return this.runtime.click(normalized);
+  }
+  async hover(input) {
+    const normalized = normalizeTargetOptions(input);
+    return this.runtime.hover(normalized);
+  }
+  async input(input) {
+    const normalized = normalizeTargetOptions(input);
+    return this.runtime.input({
+      ...normalized,
+      text: input.text,
+      ...input.pressEnter === void 0 ? {} : { pressEnter: input.pressEnter }
     });
-    this.lastPoint = point;
   }
-  async pulse(point, style) {
-    const pulseSize = style.size * style.pulseScale;
-    const pulseFill = {
-      ...style.fillColor,
-      a: Math.min(1, style.fillColor.a * 0.14)
-    };
-    const pulseOutline = {
-      ...style.haloColor,
-      a: Math.min(1, style.haloColor.a * 0.9)
-    };
-    await this.sendWithRecovery(async (session) => {
-      await session.send("Overlay.highlightQuad", {
-        quad: buildCursorQuad(point, pulseSize),
-        color: toProtocolRgba(pulseFill),
-        outlineColor: toProtocolRgba(pulseOutline)
-      });
+  async scroll(input) {
+    const normalized = normalizeTargetOptions(input);
+    return this.runtime.scroll({
+      ...normalized,
+      direction: input.direction,
+      amount: input.amount
     });
-    await sleep(PULSE_DELAY_MS);
-    await this.move(point, style);
-  }
-  async clear() {
-    if (!this.session) return;
-    try {
-      await this.session.send("Overlay.hideHighlight");
-    } catch {
-      this.markInactive("cdp_detached");
-    }
   }
-  async dispose() {
-    await this.cleanupSession();
-    this.active = false;
-    this.reason = "disabled";
-    this.lastMessage = void 0;
-    this.lastPoint = null;
-    this.page = null;
-  }
-  async sendWithRecovery(operation) {
-    if (!this.active || !this.session) return;
-    try {
-      await operation(this.session);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      this.lastMessage = message;
-      if (!isRecoverableProtocolError(message) || !this.page) {
-        this.markInactive("renderer_error", message);
-        return;
+  async extract(input) {
+    const result = await this.runtime.extract(input);
+    return result.data;
+  }
+  async queryNetwork(input = {}) {
+    return this.runtime.queryNetwork(input);
+  }
+  async waitForNetwork(input) {
+    const { timeoutMs, pollIntervalMs, ...query } = input;
+    const timeoutAt = Date.now() + (timeoutMs ?? 3e4);
+    const pollInterval = pollIntervalMs ?? 100;
+    while (true) {
+      const { records } = await this.runtime.queryNetwork({
+        ...query,
+        limit: 1
+      });
+      if (records[0] !== void 0) {
+        return records[0];
       }
-      await this.createSession();
-      if (!this.active || !this.session) {
-        return;
+      if (Date.now() >= timeoutAt) {
+        throw new Error("waitForNetwork timed out");
+      }
+      await delay(pollInterval);
+    }
+  }
+  async waitForResponse(input) {
+    return this.waitForNetwork(input);
+  }
+  async waitForPage(input = {}) {
+    const baseline = new Set((await this.runtime.listPages()).pages.map((page) => page.pageRef));
+    const timeoutAt = Date.now() + (input.timeoutMs ?? 3e4);
+    const pollIntervalMs = input.pollIntervalMs ?? 100;
+    while (true) {
+      const { pages } = await this.runtime.listPages();
+      const match = pages.find((page) => {
+        if (baseline.has(page.pageRef)) {
+          return false;
+        }
+        if (input.openerPageRef !== void 0 && page.openerPageRef !== input.openerPageRef) {
+          return false;
+        }
+        if (input.urlIncludes !== void 0 && !page.url.includes(input.urlIncludes)) {
+          return false;
+        }
+        return true;
+      });
+      if (match !== void 0) {
+        return match;
       }
-      try {
-        await operation(this.session);
-      } catch (retryError) {
-        const retryMessage = retryError instanceof Error ? retryError.message : String(retryError);
-        this.markInactive("renderer_error", retryMessage);
+      if (Date.now() >= timeoutAt) {
+        throw new Error("waitForPage timed out");
       }
+      await delay(pollIntervalMs);
     }
   }
-  async createSession() {
-    if (!this.page || this.page.isClosed()) {
-      this.markInactive("page_closed");
+  async saveNetwork(input) {
+    return this.runtime.saveNetwork(input);
+  }
+  async minimizeNetwork(input) {
+    return this.runtime.minimizeNetwork(input);
+  }
+  async diffNetwork(input) {
+    return this.runtime.diffNetwork(input);
+  }
+  async probeNetwork(input) {
+    return this.runtime.probeNetwork(input);
+  }
+  async reverseDiscover(input = {}) {
+    return this.runtime.discoverReverse(input);
+  }
+  async reverseQuery(input) {
+    return this.runtime.queryReverse(input);
+  }
+  async createReversePackage(input) {
+    return this.runtime.createReversePackage(input);
+  }
+  async runReversePackage(input) {
+    return this.runtime.runReversePackage(input);
+  }
+  async reverseExport(input) {
+    return this.runtime.exportReverse(input);
+  }
+  async reverseReport(input) {
+    return this.runtime.getReverseReport(input);
+  }
+  async getReversePackage(input) {
+    return this.runtime.getReversePackage(input);
+  }
+  async listReversePackages(input = {}) {
+    return this.runtime.listReversePackages(input);
+  }
+  async patchReversePackage(input) {
+    return this.runtime.patchReversePackage(input);
+  }
+  async interactionCapture(input) {
+    return this.runtime.captureInteraction(input);
+  }
+  async getInteraction(input) {
+    return this.runtime.getInteraction(input);
+  }
+  async interactionDiff(input) {
+    return this.runtime.diffInteraction(input);
+  }
+  async interactionReplay(input) {
+    return this.runtime.replayInteraction(input);
+  }
+  async clearNetwork(input = {}) {
+    return this.runtime.clearNetwork(input);
+  }
+  async captureScripts(input = {}) {
+    return this.runtime.captureScripts(input);
+  }
+  async readArtifact(input) {
+    return this.runtime.readArtifact(input);
+  }
+  async beautifyScript(input) {
+    return this.runtime.beautifyScript(input);
+  }
+  async deobfuscateScript(input) {
+    return this.runtime.deobfuscateScript(input);
+  }
+  async sandboxScript(input) {
+    return this.runtime.sandboxScript(input);
+  }
+  async solveCaptcha(input) {
+    return this.runtime.solveCaptcha(input);
+  }
+  async getCookies(input = {}) {
+    return this.runtime.getCookies(input);
+  }
+  async getStorageSnapshot(input = {}) {
+    return this.runtime.getStorageSnapshot(input);
+  }
+  async writeRequestPlan(input) {
+    return this.runtime.writeRequestPlan(input);
+  }
+  async inferRequestPlan(input) {
+    return this.runtime.inferRequestPlan(input);
+  }
+  async getRequestPlan(input) {
+    return this.runtime.getRequestPlan(input);
+  }
+  async listRequestPlans(input = {}) {
+    return this.runtime.listRequestPlans(input);
+  }
+  async writeAuthRecipe(input) {
+    return this.runtime.writeAuthRecipe(input);
+  }
+  async writeRecipe(input) {
+    return this.runtime.writeRecipe(input);
+  }
+  async getAuthRecipe(input) {
+    return this.runtime.getAuthRecipe(input);
+  }
+  async getRecipe(input) {
+    return this.runtime.getRecipe(input);
+  }
+  async listAuthRecipes(input = {}) {
+    return this.runtime.listAuthRecipes(input);
+  }
+  async listRecipes(input = {}) {
+    return this.runtime.listRecipes(input);
+  }
+  async runAuthRecipe(input) {
+    return this.runtime.runAuthRecipe(input);
+  }
+  async runRecipe(input) {
+    return this.runtime.runRecipe(input);
+  }
+  async request(key, input = {}) {
+    return this.runtime.request({
+      key,
+      ...input
+    });
+  }
+  async rawRequest(input) {
+    return this.runtime.rawRequest(input);
+  }
+  async route(input) {
+    return this.requireOwnedInstrumentationRuntime("route").route(input);
+  }
+  async interceptScript(input) {
+    return this.requireOwnedInstrumentationRuntime("interceptScript").interceptScript(input);
+  }
+  async computerExecute(input) {
+    return this.runtime.computerExecute(input);
+  }
+  async close() {
+    return this.runtime.close();
+  }
+  async disconnect() {
+    if (this.ownership === "owned") {
+      await this.close();
       return;
     }
-    await this.cleanupSession();
-    try {
-      const session = await this.page.context().newCDPSession(this.page);
-      await session.send("DOM.enable");
-      await session.send("Overlay.enable");
-      this.session = session;
-      this.active = true;
-      this.reason = void 0;
-      this.lastMessage = void 0;
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      this.markInactive(inferSetupReason(message), message);
-      await this.cleanupSession();
+    if (isDisconnectableRuntime(this.runtime)) {
+      await this.runtime.disconnect();
     }
   }
-  async cleanupSession() {
-    const session = this.session;
-    this.session = null;
-    if (!session) return;
-    try {
-      await session.detach();
-    } catch {
-    }
+  static fromRuntime(runtime, ownership) {
+    const instance = Object.create(_Opensteer.prototype);
+    instance.runtime = runtime;
+    instance.ownership = ownership;
+    return instance;
   }
-  markInactive(reason, message) {
-    this.active = false;
-    this.reason = reason;
-    this.lastMessage = message;
+  requireOwnedInstrumentationRuntime(method) {
+    if (this.runtime instanceof OpensteerSessionRuntime) {
+      return this.runtime;
+    }
+    throw new Error(`${method}() is only available on owned local SDK sessions.`);
   }
 };
-function buildCursorQuad(point, size) {
-  const x = point.x;
-  const y = point.y;
-  return [
-    // Point 0: Tip (the hotspot)
-    roundPointValue(x),
-    roundPointValue(y),
-    // Point 1: Right shoulder — extends right and down
-    roundPointValue(x + size * 0.45),
-    roundPointValue(y + size * 0.78),
-    // Point 2: Tail — bottom of the cursor shaft
-    roundPointValue(x + size * 0.12),
-    roundPointValue(y + size * 1.3),
-    // Point 3: Left edge — stays close to the shaft
-    roundPointValue(x - size * 0.04),
-    roundPointValue(y + size * 0.62)
-  ];
+function assertAttachedOpenInputAllowed(input) {
+  if (input.browser !== void 0 || input.context !== void 0 || input.name !== void 0) {
+    throw new Error(
+      "Opensteer.attach(...) reuses an existing session. open() may only receive url when attached."
+    );
+  }
 }
-function inferSetupReason(message) {
-  const lowered = message.toLowerCase();
-  if (lowered.includes("not supported") || lowered.includes("only supported") || lowered.includes("unknown command")) {
-    return "unsupported";
+function isDisconnectableRuntime(runtime) {
+  return "disconnect" in runtime;
+}
+function normalizeTargetOptions(input) {
+  const hasElement = input.element !== void 0;
+  const hasSelector = input.selector !== void 0;
+  if (hasElement && hasSelector) {
+    throw new Error("Specify exactly one of element, selector, or description.");
+  }
+  if (hasElement) {
+    return {
+      target: {
+        kind: "element",
+        element: input.element
+      },
+      ...input.description === void 0 ? {} : { persistAsDescription: input.description },
+      ...input.networkTag === void 0 ? {} : { networkTag: input.networkTag }
+    };
+  }
+  if (hasSelector) {
+    return {
+      target: {
+        kind: "selector",
+        selector: input.selector
+      },
+      ...input.description === void 0 ? {} : { persistAsDescription: input.description },
+      ...input.networkTag === void 0 ? {} : { networkTag: input.networkTag }
+    };
   }
-  return "cdp_unavailable";
+  if (input.description === void 0) {
+    throw new Error("Specify exactly one of element, selector, or description.");
+  }
+  return {
+    target: {
+      kind: "description",
+      description: input.description
+    },
+    ...input.networkTag === void 0 ? {} : { networkTag: input.networkTag }
+  };
 }
-function isRecoverableProtocolError(message) {
-  const lowered = message.toLowerCase();
-  return lowered.includes("session closed") || lowered.includes("target closed") || lowered.includes("has been closed") || lowered.includes("detached");
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
 }
-function toProtocolRgba(color) {
+
+// src/behavior/mouse.ts
+function generateMousePath(input) {
+  const dx = input.end.x - input.start.x;
+  const dy = input.end.y - input.start.y;
+  const distance = Math.hypot(dx, dy);
+  const durationMs = input.durationMs ?? Math.max(180, Math.round(distance * 2.2));
+  const fps = input.fps ?? 60;
+  const jitter = input.jitter ?? 3;
+  const curvature = input.curvature ?? 0.3;
+  const frameCount = Math.max(2, Math.round(durationMs / 1e3 * fps));
+  const normal = distance === 0 ? { x: 0, y: 1 } : { x: -dy / distance, y: dx / distance };
+  const controlDistance = distance * curvature;
+  const control1 = {
+    x: input.start.x + dx * 0.33 + normal.x * controlDistance,
+    y: input.start.y + dy * 0.33 + normal.y * controlDistance
+  };
+  const control2 = {
+    x: input.start.x + dx * 0.66 - normal.x * controlDistance * 0.6,
+    y: input.start.y + dy * 0.66 - normal.y * controlDistance * 0.6
+  };
+  const points = [];
+  for (let index = 0; index <= frameCount; index += 1) {
+    const linear = index / frameCount;
+    const eased = easeInOutCubic(linear);
+    const base = cubicBezier(input.start, control1, control2, input.end, eased);
+    const noise = index === 0 || index === frameCount ? 0 : gaussianRandom() * jitter;
+    points.push({
+      x: base.x + normal.x * noise,
+      y: base.y + normal.y * noise,
+      t: Math.round(linear * durationMs)
+    });
+  }
   return {
-    r: clampColor(color.r),
-    g: clampColor(color.g),
-    b: clampColor(color.b),
-    a: clampAlpha(color.a)
+    points,
+    durationMs
   };
 }
-function clampColor(value) {
-  return Math.min(255, Math.max(0, Math.round(value)));
+function generateDragTrail(input) {
+  return generateMousePath({
+    start: input.start,
+    end: input.end,
+    ...input.durationMs === void 0 ? {} : { durationMs: input.durationMs },
+    ...input.fps === void 0 ? {} : { fps: input.fps },
+    jitter: 1.5,
+    curvature: 0.18
+  });
 }
-function clampAlpha(value) {
-  const normalized = Number.isFinite(value) ? value : 1;
-  return Math.min(1, Math.max(0, normalized));
+function cubicBezier(start, control1, control2, end, t) {
+  const inverse = 1 - t;
+  return {
+    x: inverse ** 3 * start.x + 3 * inverse ** 2 * t * control1.x + 3 * inverse * t ** 2 * control2.x + t ** 3 * end.x,
+    y: inverse ** 3 * start.y + 3 * inverse ** 2 * t * control1.y + 3 * inverse * t ** 2 * control2.y + t ** 3 * end.y
+  };
 }
-function roundPointValue(value) {
-  return Math.round(value * 100) / 100;
+function easeInOutCubic(t) {
+  return t < 0.5 ? 4 * t ** 3 : 1 - (-2 * t + 2) ** 3 / 2;
 }
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+function gaussianRandom() {
+  let u = 0;
+  let v = 0;
+  while (u === 0) {
+    u = Math.random();
+  }
+  while (v === 0) {
+    v = Math.random();
+  }
+  return Math.sqrt(-2 * Math.log(u)) * Math.cos(2 * Math.PI * v);
 }
-export {
-  ActionWsClient,
-  BrowserPool,
-  BrowserProfileClient,
-  CdpOverlayCursorRenderer,
-  CloudCdpClient,
-  CloudSessionClient,
-  CounterResolutionError,
-  CursorController,
-  ElementPathError,
-  LocalSelectorStorage,
-  OPENSTEER_HIDDEN_ATTR,
-  OPENSTEER_INTERACTIVE_ATTR,
-  OPENSTEER_SCROLLABLE_ATTR,
-  OS_BOUNDARY_ATTR,
-  OS_IFRAME_BOUNDARY_TAG,
-  OS_NODE_ID_ATTR,
-  OS_SHADOW_BOUNDARY_TAG,
-  OS_UNAVAILABLE_ATTR,
-  Opensteer,
-  OpensteerActionError,
-  OpensteerAgentActionError,
-  OpensteerAgentApiError,
-  OpensteerAgentBusyError,
-  OpensteerAgentConfigError,
-  OpensteerAgentError,
-  OpensteerAgentExecutionError,
-  OpensteerAgentProviderError,
-  OpensteerCloudError,
-  OpensteerCuaAgentHandler,
-  SvgCursorRenderer,
-  buildArrayFieldPathCandidates,
-  buildElementPathFromHandle,
-  buildElementPathFromSelector,
-  buildPathSelectorHint,
-  cleanForAction,
-  cleanForClickable,
-  cleanForExtraction,
-  cleanForFull,
-  cleanForScrollable,
-  clearCookies,
-  clearPersistentProfileSingletons,
-  cloneElementPath,
-  closeTab,
-  cloudActionMethods,
-  cloudErrorCodes,
-  cloudNotLaunchedError,
-  cloudSessionContractVersion,
-  cloudSessionSourceTypes,
-  cloudSessionStatuses,
-  cloudUnsupportedMethodError,
-  collectLocalSelectorCacheEntries,
-  countArrayItemsWithPath,
-  createCuaClient,
-  createEmptyRegistry,
-  createExtractCallback,
-  createIsolatedRuntimeProfile,
-  createResolveCallback,
-  createTab,
-  detectChromePaths,
-  expandHome,
-  exportCookies,
-  extractArrayRowsWithPaths,
-  extractArrayWithPaths,
-  extractWithPaths,
-  getCookies,
-  getElementAttributes,
-  getElementBoundingBox,
-  getElementText,
-  getElementValue,
-  getModelProvider,
-  getOrCreatePersistentProfile,
-  getPageHtml,
-  getPageTitle,
-  importCookies,
-  isCloudActionMethod,
-  isCloudErrorCode,
-  isCloudSessionSourceType,
-  isCloudSessionStatus,
-  listLocalChromeProfiles,
-  listTabs,
-  markInteractiveElements,
-  normalizeNamespace,
-  performClick,
-  performFileUpload,
-  performHover,
-  performInput,
-  performScroll,
-  performSelect,
-  persistIsolatedRuntimeProfile,
-  planSnappyCursorMotion,
-  prepareSnapshot,
-  pressKey,
-  queryAllByElementPath,
-  resolveAgentConfig,
-  resolveCounterElement,
-  resolveCountersBatch,
-  resolveElementPath,
-  resolveNamespaceDir,
-  sanitizeElementPath,
-  serializePageHTML,
-  setCookie,
-  switchTab,
-  typeText,
-  waitForVisualStability
-};
+
+// src/behavior/typing.ts
+function generateTypingCadence(input) {
+  const baseDelayMs = input.baseDelayMs ?? 75;
+  const jitterMs = input.jitterMs ?? 35;
+  const hesitationProbability = input.hesitationProbability ?? 0.08;
+  return [...input.text].map((character, index) => {
+    const previous = input.text[index - 1];
+    const punctuationPause = /[.,!?;:]/.test(previous ?? "") ? 90 : 0;
+    const whitespacePause = /\s/.test(character) ? 30 : 0;
+    const hesitation = Math.random() < hesitationProbability ? 120 + Math.random() * 180 : 0;
+    const jitter = (Math.random() * 2 - 1) * jitterMs;
+    return {
+      character,
+      delayMs: Math.max(
+        10,
+        Math.round(baseDelayMs + punctuationPause + whitespacePause + hesitation + jitter)
+      )
+    };
+  });
+}
+
+// src/behavior/scroll.ts
+function generateScrollPattern(input) {
+  const durationMs = input.durationMs ?? Math.max(220, Math.round(Math.abs(input.distancePx) * 0.9));
+  const fps = input.fps ?? 60;
+  const frames = Math.max(2, Math.round(durationMs / 1e3 * fps));
+  let previousDistance = 0;
+  const points = [];
+  for (let index = 0; index <= frames; index += 1) {
+    const progress = easeInOutQuad(index / frames);
+    const currentDistance = progress * input.distancePx;
+    points.push({
+      deltaY: Math.round(currentDistance - previousDistance),
+      t: Math.round(index / frames * durationMs)
+    });
+    previousDistance = currentDistance;
+  }
+  return {
+    points,
+    durationMs
+  };
+}
+function easeInOutQuad(t) {
+  return t < 0.5 ? 2 * t * t : 1 - (-2 * t + 2) ** 2 / 2;
+}
+
+export { Opensteer, generateDragTrail, generateMousePath, generateScrollPattern, generateTypingCadence };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map