effing-use 0.1.1 → 0.2.1

package/src/browser/evidence.ts

@@ -0,0 +1,208 @@
+import type { Page } from "playwright";
+import { getConsoleLogs, getNetworkLogs } from "./session.js";
+
+export type Effect = {
+  urlChanged: boolean;
+  urlBefore?: string;
+  urlAfter?: string;
+  domChanged: string[];
+  consoleErrors: string[];
+  dialog?: string;
+  networkFailures?: string[];
+  mustObserve: boolean;
+};
+
+const EFFECT_MAX_CHARS_DEFAULT = 800;
+
+function capEffect(effect: Effect, maxChars: number): Effect {
+  // Hard cap 800 chars total — truncate domChanged/consoleErrors/networkFailures
+  let total = JSON.stringify(effect).length;
+  if (total <= maxChars) return effect;
+  // Trim arrays until under cap
+  while (total > maxChars && effect.domChanged.length > 0) {
+    effect.domChanged.pop();
+    total = JSON.stringify(effect).length;
+  }
+  while (total > maxChars && effect.consoleErrors.length > 0) {
+    effect.consoleErrors.pop();
+    total = JSON.stringify(effect).length;
+  }
+  while (total > maxChars && (effect.networkFailures?.length ?? 0) > 0) {
+    effect.networkFailures!.pop();
+    total = JSON.stringify(effect).length;
+  }
+  return effect;
+}
+
+export async function collectEffect(
+  page: Page,
+  sessionId: string,
+  urlBefore: string,
+  domBeforeHash: string | null,
+  consoleBeforeLen: number,
+  networkBeforeLen: number,
+  maxChars = EFFECT_MAX_CHARS_DEFAULT,
+): Promise<Effect> {
+  const urlAfter = page.url();
+  const urlChanged = urlBefore !== urlAfter;
+
+  // domChanged: line-level diff of body.innerText (50k cap). v0.2 only
+  // compared the first 200 chars, so any below-fold change looked like a no-op
+  // (and fed the failure contract wrong "no DOM change" signals).
+  let domChanged: string[] = [];
+  try {
+    const currentDom = await page.evaluate(
+      () => document.body?.innerText?.slice(0, 50000) ?? "",
+    );
+    if (domBeforeHash !== null && currentDom !== domBeforeHash) {
+      const before = new Set(
+        domBeforeHash
+          .split("\n")
+          .map((l) => l.trim())
+          .filter(Boolean),
+      );
+      const after = currentDom
+        .split("\n")
+        .map((l) => l.trim())
+        .filter(Boolean);
+      const afterSet = new Set(after);
+      const changed = after
+        .filter((l) => !before.has(l))
+        .slice(0, 5)
+        .map((l) => l.slice(0, 140));
+      const removed = [...before]
+        .filter((l) => !afterSet.has(l))
+        .slice(0, 3)
+        .map((l) => `- ${l.slice(0, 138)}`);
+      domChanged = [...changed, ...removed].slice(0, 5);
+    }
+  } catch {
+    // ignore
+  }
+
+  const consoleLogs = getConsoleLogs(sessionId);
+  const newConsole = consoleLogs.slice(consoleBeforeLen);
+  const consoleErrors = newConsole
+    .filter((c) => c.type === "error")
+    .slice(-3)
+    .map((c) => c.text.slice(0, 200));
+
+  const networkLogs = getNetworkLogs(sessionId);
+  const newNetwork = networkLogs.slice(networkBeforeLen);
+  const networkFailures = newNetwork
+    .filter((r) => r.status >= 400)
+    .slice(-3)
+    .map((r) => `${r.method} ${r.url.slice(0, 80)} → ${r.status}`);
+
+  // dialog detection: check if page has dialog handler armed? For now undefined
+  const effect: Effect = {
+    urlChanged,
+    ...(urlChanged ? { urlBefore, urlAfter } : {}),
+    domChanged: domChanged.slice(0, 5),
+    consoleErrors: consoleErrors.slice(0, 3),
+    ...(networkFailures.length ? { networkFailures } : {}),
+    mustObserve: false,
+  };
+
+  return capEffect(effect, maxChars);
+}
+
+const EXPECT_MAX_PATTERN = 200;
+
+export function parseExpect(
+  expect: string,
+): { kind: string; pattern: string } | null {
+  const s = expect.trim();
+  let parsed: { kind: string; pattern: string } | null = null;
+  if (s.startsWith("url~")) parsed = { kind: "url", pattern: s.slice(4) };
+  else if (s.startsWith("text~"))
+    parsed = { kind: "text", pattern: s.slice(5) };
+  else if (s.startsWith("visible="))
+    parsed = { kind: "visible", pattern: s.slice(8) };
+  else if (s.startsWith("gone="))
+    parsed = { kind: "gone", pattern: s.slice(5) };
+  else return null;
+  if (parsed.pattern.length > EXPECT_MAX_PATTERN) return null;
+  // Validate regex patterns early for url~/text~
+  if (parsed.kind === "url" || parsed.kind === "text") {
+    try {
+      new RegExp(parsed.pattern);
+    } catch {
+      return null;
+    }
+  }
+  return parsed;
+}
+
+export async function evaluateExpect(
+  page: Page,
+  expect: string,
+): Promise<{ ok: boolean; message?: string }> {
+  const parsed = parseExpect(expect);
+  if (!parsed) {
+    return {
+      ok: false,
+      message: `Bad expect syntax "${expect}". Use url~<regex> | text~<regex> | visible=<css> | gone=<css>`,
+    };
+  }
+  try {
+    switch (parsed.kind) {
+      case "url": {
+        const re = new RegExp(parsed.pattern);
+        const url = page.url();
+        if (re.test(url)) return { ok: true };
+        return {
+          ok: false,
+          message: `url "${url}" does not match /${parsed.pattern}/`,
+        };
+      }
+      case "text": {
+        const text = await page.innerText("body").catch(() => "");
+        const slice = text.slice(0, 50000);
+        const re = new RegExp(parsed.pattern);
+        if (re.test(slice)) return { ok: true };
+        return {
+          ok: false,
+          message: `page text does not match /${parsed.pattern}/`,
+        };
+      }
+      case "visible": {
+        const loc = page.locator(parsed.pattern);
+        const count = await loc.count().catch(() => 0);
+        if (count === 0)
+          return {
+            ok: false,
+            message: `selector "${parsed.pattern}" not found`,
+          };
+        const visible = await loc
+          .first()
+          .isVisible()
+          .catch(() => false);
+        if (visible) return { ok: true };
+        return {
+          ok: false,
+          message: `selector "${parsed.pattern}" not visible`,
+        };
+      }
+      case "gone": {
+        const loc = page.locator(parsed.pattern);
+        const count = await loc.count().catch(() => 0);
+        if (count === 0) return { ok: true };
+        const visible = await loc
+          .first()
+          .isVisible()
+          .catch(() => false);
+        if (!visible) return { ok: true };
+        return {
+          ok: false,
+          message: `selector "${parsed.pattern}" still visible`,
+        };
+      }
+      default:
+        return { ok: false, message: `Unknown expect kind "${parsed.kind}"` };
+    }
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return { ok: false, message: `expect evaluation failed: ${msg}` };
+  }
+}

package/src/browser/identity.ts

@@ -0,0 +1,237 @@
+import type { Page } from "playwright";
+
+export type Fingerprint = {
+  role: string;
+  accessibleName: string;
+  textHash: string;
+  box: { x: number; y: number; w: number; h: number };
+  pathHash: string;
+};
+
+/** Raw per-element data as extracted inside the page (before normalization). */
+export type RawFp = {
+  role: string;
+  accessibleName: string;
+  text: string;
+  pathHash: string;
+  box: { x: number; y: number; w: number; h: number };
+};
+
+/**
+ * Browser-side fingerprint extractor — SINGLE SOURCE OF TRUTH shared by
+ * snapshot registration, stale-ref validation and rebind search. Serialized
+ * into the page as a string so it never closes over module scope.
+ *
+ * v0.2 bug fixed here: fingerprints used tag-name roles ("input"), aria-label
+ * only, and own textContent (always "" for form controls), so every bare
+ * checkbox shared one identity — rebind then clicked the wrong element
+ * (TodoMVC: stale item toggle rebound to toggle-all). Now:
+ * - role: implicit ARIA role (input[type=checkbox] → "checkbox")
+ * - accessibleName: aria-label → <label> → alt → title → placeholder → text
+ * - textHash: own text, else contextual text (nearest li/label/td/row), else
+ *   placeholder — so item toggles carry their todo text
+ */
+export const RAW_FP_SCRIPT = `(() => {
+  const SEL = "button, a, input, select, textarea, [role=button], [tabindex]";
+  const norm = (s) => (s || "").trim().replace(/\\s+/g, " ").slice(0, 80);
+  const implicitRole = (el) => {
+    const r = el.getAttribute("role");
+    if (r) return r;
+    const tag = el.tagName.toLowerCase();
+    if (tag === "a") return el.hasAttribute("href") ? "link" : "generic";
+    if (tag === "button") return "button";
+    if (tag === "textarea") return "textbox";
+    if (tag === "select") return "combobox";
+    if (tag === "summary") return "button";
+    if (tag === "input") {
+      const t = (el.getAttribute("type") || "text").toLowerCase();
+      if (t === "checkbox") return "checkbox";
+      if (t === "radio") return "radio";
+      if (t === "submit" || t === "button" || t === "reset" || t === "image") return "button";
+      if (t === "range") return "slider";
+      if (t === "hidden") return "hidden";
+      return "textbox";
+    }
+    return tag;
+  };
+  const accName = (el) => {
+    const aria = el.getAttribute("aria-label");
+    if (aria && aria.trim()) return norm(aria);
+    if (el.labels && el.labels.length > 0) {
+      const t = norm(el.labels[0].textContent);
+      if (t) return t;
+    }
+    const alt = el.getAttribute("alt");
+    if (alt && alt.trim()) return norm(alt);
+    const title = el.getAttribute("title");
+    if (title && title.trim()) return norm(title);
+    const ph = el.getAttribute("placeholder");
+    if (ph && ph.trim()) return norm(ph);
+    return norm(el.textContent);
+  };
+  const textOf = (el) => {
+    const own = norm(el.textContent);
+    if (own) return own;
+    const ctx = el.closest && el.closest("li, label, td, [role=listitem], [role=row]");
+    if (ctx) {
+      const t = norm(ctx.textContent);
+      if (t) return t;
+    }
+    return norm(el.getAttribute("placeholder"));
+  };
+  const pathOf = (el) => {
+    const parts = [];
+    let cur = el;
+    while (cur && parts.length < 6) {
+      parts.push(cur.tagName.toLowerCase());
+      cur = cur.parentElement;
+    }
+    return parts.join(">");
+  };
+  const els = Array.prototype.slice.call(document.querySelectorAll(SEL), 0, 200);
+  return els.map((el) => {
+    const rect = el.getBoundingClientRect();
+    return {
+      role: implicitRole(el),
+      accessibleName: accName(el),
+      text: textOf(el),
+      pathHash: pathOf(el),
+      box: {
+        x: Math.round(rect.x),
+        y: Math.round(rect.y),
+        w: Math.round(rect.width),
+        h: Math.round(rect.height)
+      }
+    };
+  });
+})()`;
+
+/** Extract fingerprints for every snapshot-visible element, as e-refs. */
+export async function extractFingerprints(
+  page: Page,
+): Promise<Array<{ ref: string; fp: Fingerprint }>> {
+  const raw = (await page
+    .evaluate(RAW_FP_SCRIPT)
+    .catch(() => [] as RawFp[])) as RawFp[];
+  return raw.map((r, i) => ({ ref: `e${i}`, fp: buildFingerprint(r) }));
+}
+
+function hashText(s: string): string {
+  return s.trim().replace(/\s+/g, " ").slice(0, 80);
+}
+
+function boxKey(box: { x: number; y: number; w: number; h: number }): string {
+  return `${Math.round(box.x)}:${Math.round(box.y)}:${Math.round(box.w)}:${Math.round(box.h)}`;
+}
+
+// Per-session registry: sessionId -> Map<ref, Fingerprint>
+const registry = new Map<string, Map<string, Fingerprint>>();
+
+export function registerFingerprints(
+  sessionId: string,
+  entries: Array<{ ref: string; fp: Fingerprint }>,
+): void {
+  let m = registry.get(sessionId);
+  if (!m) {
+    m = new Map();
+    registry.set(sessionId, m);
+  }
+  // Never recycle within session — but allow overwrite on fresh snapshot
+  for (const { ref, fp } of entries) m.set(ref, fp);
+}
+
+export function getFingerprint(
+  sessionId: string,
+  ref: string,
+): Fingerprint | undefined {
+  return registry.get(sessionId)?.get(ref);
+}
+
+export function clearRegistry(sessionId: string): void {
+  registry.delete(sessionId);
+}
+
+export type RebindCandidate = { index: number; fp: Fingerprint };
+
+/**
+ * Conservative rebind ladder (P0 fix): pick an element only when the match is
+ * UNAMBIGUOUS — never guess among equals.
+ *
+ * 1. loose match (role + accessibleName + textHash) — unique → take it
+ * 2. multiple loose → narrow by identical pathHash; still >1 → give up
+ * 3. no loose → fuzzy (role + name/text contains) under the same rules
+ *
+ * Returns the chosen candidate index, or null when zero or more than one
+ * candidate survives — callers turn null into E_STALE (fail loud) instead of
+ * clicking the wrong element.
+ */
+export function chooseRebindIndex(
+  expected: Fingerprint,
+  candidates: RebindCandidate[],
+): number | null {
+  const narrow = (pool: RebindCandidate[]): number | null => {
+    if (pool.length === 1) return pool[0].index;
+    if (pool.length > 1 && expected.pathHash) {
+      const byPath = pool.filter((c) => c.fp.pathHash === expected.pathHash);
+      if (byPath.length === 1) return byPath[0].index;
+    }
+    return null;
+  };
+  const loose = candidates.filter((c) => looseMatch(expected, c.fp));
+  if (loose.length > 0) return narrow(loose);
+  const fuzzy = candidates.filter((c) => fuzzyMatch(expected, c.fp));
+  return narrow(fuzzy);
+}
+
+export function fingerprintEquals(a: Fingerprint, b: Fingerprint): boolean {
+  return (
+    a.role === b.role &&
+    a.accessibleName === b.accessibleName &&
+    a.textHash === b.textHash &&
+    boxKey(a.box) === boxKey(b.box) &&
+    a.pathHash === b.pathHash
+  );
+}
+
+// Loose match for rebind: role + name + textHash (ignore box/path)
+export function looseMatch(a: Fingerprint, b: Fingerprint): boolean {
+  return (
+    a.role === b.role &&
+    a.accessibleName === b.accessibleName &&
+    a.textHash === b.textHash
+  );
+}
+
+export function fuzzyMatch(a: Fingerprint, b: Fingerprint): boolean {
+  // fuzzy: role must match, and either name or textHash matches (case-insensitive contains)
+  if (a.role !== b.role) return false;
+  const an = a.accessibleName.toLowerCase();
+  const bn = b.accessibleName.toLowerCase();
+  const at = a.textHash.toLowerCase();
+  const bt = b.textHash.toLowerCase();
+  const nameMatch = an && bn && (an.includes(bn) || bn.includes(an));
+  const textMatch = at && bt && (at.includes(bt) || bt.includes(at));
+  return Boolean(nameMatch || textMatch);
+}
+
+// Build fingerprint from evaluated element data
+export function buildFingerprint(data: {
+  role: string;
+  accessibleName: string;
+  text: string;
+  box: { x: number; y: number; w: number; h: number };
+  pathHash: string;
+}): Fingerprint {
+  return {
+    role: data.role || "generic",
+    accessibleName: (data.accessibleName || "").trim().slice(0, 80),
+    textHash: hashText(data.text || ""),
+    box: {
+      x: Math.round(data.box.x),
+      y: Math.round(data.box.y),
+      w: Math.round(data.box.w),
+      h: Math.round(data.box.h),
+    },
+    pathHash: data.pathHash || "",
+  };
+}

package/src/browser/macro.ts

@@ -0,0 +1,118 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import type { Config } from "../config.js";
+import type { RecordStep } from "./record.js";
+
+const IRREVERSIBLE = /submit|send|buy|pay|delete|remove|publish|post|confirm/i;
+
+export function isIrreversible(step: RecordStep): boolean {
+  const hay = [step.op, step.target ?? "", step.value ?? ""].join(" ");
+  return IRREVERSIBLE.test(hay);
+}
+
+function selectorFor(step: RecordStep): string {
+  if (step.resolvedSelector) return step.resolvedSelector;
+  if (step.target) return step.target;
+  return "";
+}
+
+function sanitizeMacroName(s: string): string {
+  return s.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64) || "macro";
+}
+
+export async function compileMacro(
+  config: Config,
+  name: string,
+  steps: RecordStep[],
+): Promise<{ tsPath: string; mdPath: string; warnings: string[] }> {
+  const safe = sanitizeMacroName(name);
+  const dir = join(config.outputDir, "macros");
+  await mkdir(dir, { recursive: true });
+
+  const warnings: string[] = [];
+  const irreversibleSteps = steps.filter(isIrreversible);
+  if (irreversibleSteps.length > 0) {
+    // Steps are human-facing here — 1-indexed, matching the .md step list
+    warnings.push(
+      `${irreversibleSteps.length} step(s) require approval: steps ${irreversibleSteps
+        .map((s) => s.seq + 1)
+        .join(", ")}`,
+    );
+  }
+
+  // TS macro
+  const tsLines: string[] = [
+    `// macro: ${name} — generated by effing-use compile`,
+    `// steps: ${steps.length}, requiresApproval: ${irreversibleSteps.length > 0}`,
+    `import type { Page } from "playwright";`,
+    ``,
+    `export async function run(page: Page) {`,
+  ];
+  for (const s of steps) {
+    const sel = selectorFor(s);
+    const val = (s.value ?? "").slice(0, 500);
+    const flag = isIrreversible(s) ? " // requiresApproval" : "";
+    // Recordings made before stable-selector resolution store session-scoped
+    // e-refs — flag them so nobody runs the .ts standalone expecting it to work.
+    const staleNote = /^e\d+$/.test(sel)
+      ? " /* session-scoped e-ref — not a standalone selector */"
+      : "";
+    switch (s.op) {
+      case "click":
+        tsLines.push(
+          `  await page.locator(${JSON.stringify(sel)}).click();${flag}${staleNote}`,
+        );
+        break;
+      case "fill":
+        tsLines.push(
+          `  await page.locator(${JSON.stringify(sel)}).fill(${JSON.stringify(val)});${flag}${staleNote}`,
+        );
+        break;
+      case "press":
+        tsLines.push(
+          `  await page.keyboard.press(${JSON.stringify(val || s.target || "Enter")});${flag}`,
+        );
+        break;
+      case "goto":
+      case "open":
+        tsLines.push(
+          `  await page.goto(${JSON.stringify(val || sel)});${flag}`,
+        );
+        break;
+      default:
+        tsLines.push(
+          `  // ${JSON.stringify(s.op)} ${JSON.stringify(sel)} ${JSON.stringify(val)}${flag}`,
+        );
+        break;
+    }
+  }
+  tsLines.push(`}`);
+  tsLines.push(``);
+
+  const tsPath = join(dir, `${safe}.ts`);
+  await writeFile(tsPath, tsLines.join("\n"), "utf-8");
+
+  // SKILL.md
+  const mdLines: string[] = [
+    `# Skill: ${safe}`,
+    ``,
+    `When to use: replay this ${steps.length}-step flow via \`browser_act action=replay value=${safe}\`.`,
+    ``,
+    `## Steps`,
+    ...steps.map((s) =>
+      `${s.seq + 1}. ${s.op} ${s.target ?? ""} ${s.value ?? ""}${isIrreversible(s) ? " (requires approval)" : ""}`.trim(),
+    ),
+    ``,
+    `## Verification`,
+    irreversibleSteps.length > 0
+      ? `This macro contains irreversible steps — replay will pause with E_APPROVAL_REQUIRED until approve:true.`
+      : `No approval-gated steps.`,
+    ``,
+    `## Inputs`,
+    `None in v1 — values are baked in. Parameterize in a future version if needed.`,
+  ];
+  const mdPath = join(dir, `${safe}.md`);
+  await writeFile(mdPath, mdLines.join("\n"), "utf-8");
+
+  return { tsPath, mdPath, warnings };
+}

package/src/browser/record.ts

@@ -0,0 +1,149 @@
+import { mkdir, writeFile, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import type { Config } from "../config.js";
+import type { Fingerprint } from "./identity.js";
+
+export type RecordStep = {
+  seq: number;
+  op: string;
+  target?: string;
+  value?: string;
+  targetFingerprint?: Fingerprint;
+  resolvedSelector?: string;
+  expect?: string;
+  valueRedacted?: boolean;
+};
+
+type Recording = {
+  name: string;
+  createdAt: string;
+  steps: RecordStep[];
+};
+
+const activeRecordings = new Map<
+  string,
+  { name: string; steps: RecordStep[] }
+>();
+
+const SECRET_HINT = /password|otp|secret|token|pin|ssn/i;
+
+function isSecretField(
+  fp?: Fingerprint,
+  target?: string,
+  value?: string,
+): boolean {
+  const hay = [fp?.accessibleName ?? "", fp?.role ?? "", target ?? ""].join(
+    " ",
+  );
+  if (SECRET_HINT.test(hay)) return true;
+  // also check input type=password via target string
+  if (/type\s*=\s*password/i.test(target ?? "")) return true;
+  return false;
+}
+
+export function isRecording(sessionId: string): boolean {
+  return activeRecordings.has(sessionId);
+}
+
+export function startRecording(sessionId: string, name: string): void {
+  activeRecordings.set(sessionId, { name, steps: [] });
+}
+
+export function stopRecording(
+  sessionId: string,
+): { name: string; steps: RecordStep[] } | null {
+  const r = activeRecordings.get(sessionId);
+  if (!r) return null;
+  activeRecordings.delete(sessionId);
+  return r;
+}
+
+export function captureStep(
+  sessionId: string,
+  step: Omit<RecordStep, "seq">,
+  config: Config,
+): void {
+  const rec = activeRecordings.get(sessionId);
+  if (!rec) return;
+  const seq = rec.steps.length;
+  let value = step.value;
+  let valueRedacted = false;
+  if (
+    config.recordRedact &&
+    value &&
+    isSecretField(step.targetFingerprint, step.target, value)
+  ) {
+    value = "«redacted»";
+    valueRedacted = true;
+  }
+  rec.steps.push({
+    seq,
+    ...step,
+    value,
+    ...(valueRedacted ? { valueRedacted: true } : {}),
+  });
+}
+
+function sanitizeName(s: string): string {
+  return s.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64) || "recording";
+}
+
+export async function saveRecording(
+  config: Config,
+  name: string,
+  steps: RecordStep[],
+): Promise<string> {
+  const safe = sanitizeName(name);
+  const dir = join(config.outputDir, "recordings");
+  await mkdir(dir, { recursive: true });
+  const path = join(dir, `${safe}.json`);
+  const rec: Recording = {
+    name: safe,
+    createdAt: new Date().toISOString(),
+    steps,
+  };
+  await writeFile(path, JSON.stringify(rec, null, 2), "utf-8");
+  return path;
+}
+
+export async function loadRecording(
+  config: Config,
+  name: string,
+): Promise<Recording> {
+  const safe = sanitizeName(name);
+  const path = join(config.outputDir, "recordings", `${safe}.json`);
+  const raw = await readFile(path, "utf-8");
+  return JSON.parse(raw) as Recording;
+}
+
+export function getActiveName(sessionId: string): string | null {
+  return activeRecordings.get(sessionId)?.name ?? null;
+}
+
+// ---------------------------------------------------------------- replay cursor
+// Plan §6.3: pause AT an approval-gated step and resume with approve:true —
+// the cursor keeps the benign prefix from running twice (non-idempotent steps).
+const replayCursors = new Map<string, number>();
+
+function cursorKey(sessionId: string, name: string): string {
+  return `${sessionId}:${name}`;
+}
+
+export function getReplayCursor(
+  sessionId: string,
+  name: string,
+): number | undefined {
+  return replayCursors.get(cursorKey(sessionId, name));
+}
+
+export function setReplayCursor(
+  sessionId: string,
+  name: string,
+  step: number,
+): void {
+  replayCursors.set(cursorKey(sessionId, name), step);
+}
+
+export function clearReplayCursor(sessionId: string, name: string): void {
+  replayCursors.delete(cursorKey(sessionId, name));
+}