@userreason/wizard 0.1.0 → 0.2.1

package/dist/chunk-5SC2K42Q.js

@@ -0,0 +1,899 @@
+import { createRequire as createWizardRequire } from 'node:module'; import { fileURLToPath as wizardFileURLToPath } from 'node:url'; import { dirname as wizardDirname } from 'node:path'; const require = createWizardRequire(import.meta.url); const __filename = wizardFileURLToPath(import.meta.url); const __dirname = wizardDirname(__filename);
+import {
+  DEFAULT_API,
+  initializationSource,
+  integrationSource
+} from "./chunk-YMSGDC4B.js";
+import {
+  require_typescript
+} from "./chunk-GGARVSPT.js";
+import {
+  __toESM
+} from "./chunk-WL3NOIM6.js";
+
+// src/integrate.ts
+var import_typescript = __toESM(require_typescript(), 1);
+
+// node_modules/diff/libesm/diff/base.js
+var Diff = class {
+  diff(oldStr, newStr, options = {}) {
+    let callback;
+    if (typeof options === "function") {
+      callback = options;
+      options = {};
+    } else if ("callback" in options) {
+      callback = options.callback;
+    }
+    const oldString = this.castInput(oldStr, options);
+    const newString = this.castInput(newStr, options);
+    const oldTokens = this.removeEmpty(this.tokenize(oldString, options));
+    const newTokens = this.removeEmpty(this.tokenize(newString, options));
+    return this.diffWithOptionsObj(oldTokens, newTokens, options, callback);
+  }
+  diffWithOptionsObj(oldTokens, newTokens, options, callback) {
+    var _a;
+    const done = (value) => {
+      value = this.postProcess(value, options);
+      if (callback) {
+        setTimeout(function() {
+          callback(value);
+        }, 0);
+        return void 0;
+      } else {
+        return value;
+      }
+    };
+    const newLen = newTokens.length, oldLen = oldTokens.length;
+    let editLength = 1;
+    let maxEditLength = newLen + oldLen;
+    if (options.maxEditLength != null) {
+      maxEditLength = Math.min(maxEditLength, options.maxEditLength);
+    }
+    const maxExecutionTime = (_a = options.timeout) !== null && _a !== void 0 ? _a : Infinity;
+    const abortAfterTimestamp = Date.now() + maxExecutionTime;
+    const bestPath = [{ oldPos: -1, lastComponent: void 0 }];
+    let newPos = this.extractCommon(bestPath[0], newTokens, oldTokens, 0, options);
+    if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+      return done(this.buildValues(bestPath[0].lastComponent, newTokens, oldTokens));
+    }
+    let minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
+    const execEditLength = () => {
+      for (let diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
+        let basePath;
+        const removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
+        if (removePath) {
+          bestPath[diagonalPath - 1] = void 0;
+        }
+        let canAdd = false;
+        if (addPath) {
+          const addPathNewPos = addPath.oldPos - diagonalPath;
+          canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
+        }
+        const canRemove = removePath && removePath.oldPos + 1 < oldLen;
+        if (!canAdd && !canRemove) {
+          bestPath[diagonalPath] = void 0;
+          continue;
+        }
+        if (!canRemove || canAdd && removePath.oldPos < addPath.oldPos) {
+          basePath = this.addToPath(addPath, true, false, 0, options);
+        } else {
+          basePath = this.addToPath(removePath, false, true, 1, options);
+        }
+        newPos = this.extractCommon(basePath, newTokens, oldTokens, diagonalPath, options);
+        if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+          return done(this.buildValues(basePath.lastComponent, newTokens, oldTokens)) || true;
+        } else {
+          bestPath[diagonalPath] = basePath;
+          if (basePath.oldPos + 1 >= oldLen) {
+            maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
+          }
+          if (newPos + 1 >= newLen) {
+            minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
+          }
+        }
+      }
+      editLength++;
+    };
+    if (callback) {
+      (function exec() {
+        setTimeout(function() {
+          if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
+            return callback(void 0);
+          }
+          if (!execEditLength()) {
+            exec();
+          }
+        }, 0);
+      })();
+    } else {
+      while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
+        const ret = execEditLength();
+        if (ret) {
+          return ret;
+        }
+      }
+    }
+  }
+  addToPath(path, added, removed, oldPosInc, options) {
+    const last = path.lastComponent;
+    if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
+      return {
+        oldPos: path.oldPos + oldPosInc,
+        lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
+      };
+    } else {
+      return {
+        oldPos: path.oldPos + oldPosInc,
+        lastComponent: { count: 1, added, removed, previousComponent: last }
+      };
+    }
+  }
+  extractCommon(basePath, newTokens, oldTokens, diagonalPath, options) {
+    const newLen = newTokens.length, oldLen = oldTokens.length;
+    let oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
+    while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(oldTokens[oldPos + 1], newTokens[newPos + 1], options)) {
+      newPos++;
+      oldPos++;
+      commonCount++;
+      if (options.oneChangePerToken) {
+        basePath.lastComponent = { count: 1, previousComponent: basePath.lastComponent, added: false, removed: false };
+      }
+    }
+    if (commonCount && !options.oneChangePerToken) {
+      basePath.lastComponent = { count: commonCount, previousComponent: basePath.lastComponent, added: false, removed: false };
+    }
+    basePath.oldPos = oldPos;
+    return newPos;
+  }
+  equals(left, right, options) {
+    if (options.comparator) {
+      return options.comparator(left, right);
+    } else {
+      return left === right || !!options.ignoreCase && left.toLowerCase() === right.toLowerCase();
+    }
+  }
+  removeEmpty(array) {
+    const ret = [];
+    for (let i = 0; i < array.length; i++) {
+      if (array[i]) {
+        ret.push(array[i]);
+      }
+    }
+    return ret;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  castInput(value, options) {
+    return value;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  tokenize(value, options) {
+    return Array.from(value);
+  }
+  join(chars) {
+    return chars.join("");
+  }
+  postProcess(changeObjects, options) {
+    return changeObjects;
+  }
+  get useLongestToken() {
+    return false;
+  }
+  buildValues(lastComponent, newTokens, oldTokens) {
+    const components = [];
+    let nextComponent;
+    while (lastComponent) {
+      components.push(lastComponent);
+      nextComponent = lastComponent.previousComponent;
+      delete lastComponent.previousComponent;
+      lastComponent = nextComponent;
+    }
+    components.reverse();
+    const componentLen = components.length;
+    let componentPos = 0, newPos = 0, oldPos = 0;
+    for (; componentPos < componentLen; componentPos++) {
+      const component = components[componentPos];
+      if (!component.removed) {
+        if (!component.added && this.useLongestToken) {
+          let value = newTokens.slice(newPos, newPos + component.count);
+          value = value.map(function(value2, i) {
+            const oldValue = oldTokens[oldPos + i];
+            return oldValue.length > value2.length ? oldValue : value2;
+          });
+          component.value = this.join(value);
+        } else {
+          component.value = this.join(newTokens.slice(newPos, newPos + component.count));
+        }
+        newPos += component.count;
+        if (!component.added) {
+          oldPos += component.count;
+        }
+      } else {
+        component.value = this.join(oldTokens.slice(oldPos, oldPos + component.count));
+        oldPos += component.count;
+      }
+    }
+    return components;
+  }
+};
+
+// node_modules/diff/libesm/diff/line.js
+var LineDiff = class extends Diff {
+  constructor() {
+    super(...arguments);
+    this.tokenize = tokenize;
+  }
+  equals(left, right, options) {
+    if (options.ignoreWhitespace) {
+      if (!options.newlineIsToken || !left.includes("\n")) {
+        left = left.trim();
+      }
+      if (!options.newlineIsToken || !right.includes("\n")) {
+        right = right.trim();
+      }
+    } else if (options.ignoreNewlineAtEof && !options.newlineIsToken) {
+      if (left.endsWith("\n")) {
+        left = left.slice(0, -1);
+      }
+      if (right.endsWith("\n")) {
+        right = right.slice(0, -1);
+      }
+    }
+    return super.equals(left, right, options);
+  }
+};
+var lineDiff = new LineDiff();
+function diffLines(oldStr, newStr, options) {
+  return lineDiff.diff(oldStr, newStr, options);
+}
+function tokenize(value, options) {
+  if (options.stripTrailingCr) {
+    value = value.replace(/\r\n/g, "\n");
+  }
+  const retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/);
+  if (!linesAndNewlines[linesAndNewlines.length - 1]) {
+    linesAndNewlines.pop();
+  }
+  for (let i = 0; i < linesAndNewlines.length; i++) {
+    const line = linesAndNewlines[i];
+    if (i % 2 && !options.newlineIsToken) {
+      retLines[retLines.length - 1] += line;
+    } else {
+      retLines.push(line);
+    }
+  }
+  return retLines;
+}
+
+// node_modules/diff/libesm/patch/create.js
+function needsQuoting(s) {
+  for (let i = 0; i < s.length; i++) {
+    if (s[i] < " " || s[i] > "~" || s[i] === '"' || s[i] === "\\") {
+      return true;
+    }
+  }
+  return false;
+}
+function quoteFileNameIfNeeded(s) {
+  if (!needsQuoting(s)) {
+    return s;
+  }
+  let result = '"';
+  const bytes = new TextEncoder().encode(s);
+  let i = 0;
+  while (i < bytes.length) {
+    const b = bytes[i];
+    if (b === 7) {
+      result += "\\a";
+    } else if (b === 8) {
+      result += "\\b";
+    } else if (b === 9) {
+      result += "\\t";
+    } else if (b === 10) {
+      result += "\\n";
+    } else if (b === 11) {
+      result += "\\v";
+    } else if (b === 12) {
+      result += "\\f";
+    } else if (b === 13) {
+      result += "\\r";
+    } else if (b === 34) {
+      result += '\\"';
+    } else if (b === 92) {
+      result += "\\\\";
+    } else if (b >= 32 && b <= 126) {
+      result += String.fromCharCode(b);
+    } else {
+      result += "\\" + b.toString(8).padStart(3, "0");
+    }
+    i++;
+  }
+  result += '"';
+  return result;
+}
+var INCLUDE_HEADERS = {
+  includeIndex: true,
+  includeUnderline: true,
+  includeFileHeaders: true
+};
+function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
+  let optionsObj;
+  if (!options) {
+    optionsObj = {};
+  } else if (typeof options === "function") {
+    optionsObj = { callback: options };
+  } else {
+    optionsObj = options;
+  }
+  if (typeof optionsObj.context === "undefined") {
+    optionsObj.context = 4;
+  }
+  const context = optionsObj.context;
+  if (optionsObj.newlineIsToken) {
+    throw new Error("newlineIsToken may not be used with patch-generation functions, only with diffing functions");
+  }
+  if (!optionsObj.callback) {
+    return diffLinesResultToPatch(diffLines(oldStr, newStr, optionsObj));
+  } else {
+    const { callback } = optionsObj;
+    diffLines(oldStr, newStr, Object.assign(Object.assign({}, optionsObj), { callback: (diff) => {
+      const patch = diffLinesResultToPatch(diff);
+      callback(patch);
+    } }));
+  }
+  function diffLinesResultToPatch(diff) {
+    if (!diff) {
+      return;
+    }
+    diff.push({ value: "", lines: [] });
+    function contextLines(lines) {
+      return lines.map(function(entry) {
+        return " " + entry;
+      });
+    }
+    const hunks = [];
+    let oldRangeStart = 0, newRangeStart = 0, curRange = [], oldLine = 1, newLine = 1;
+    for (let i = 0; i < diff.length; i++) {
+      const current = diff[i], lines = current.lines || splitLines(current.value);
+      current.lines = lines;
+      if (current.added || current.removed) {
+        if (!oldRangeStart) {
+          const prev = diff[i - 1];
+          oldRangeStart = oldLine;
+          newRangeStart = newLine;
+          if (prev) {
+            curRange = context > 0 ? contextLines(prev.lines.slice(-context)) : [];
+            oldRangeStart -= curRange.length;
+            newRangeStart -= curRange.length;
+          }
+        }
+        for (const line of lines) {
+          curRange.push((current.added ? "+" : "-") + line);
+        }
+        if (current.added) {
+          newLine += lines.length;
+        } else {
+          oldLine += lines.length;
+        }
+      } else {
+        if (oldRangeStart) {
+          if (lines.length <= context * 2 && i < diff.length - 2) {
+            for (const line of contextLines(lines)) {
+              curRange.push(line);
+            }
+          } else {
+            const contextSize = Math.min(lines.length, context);
+            for (const line of contextLines(lines.slice(0, contextSize))) {
+              curRange.push(line);
+            }
+            const hunk = {
+              oldStart: oldRangeStart,
+              oldLines: oldLine - oldRangeStart + contextSize,
+              newStart: newRangeStart,
+              newLines: newLine - newRangeStart + contextSize,
+              lines: curRange
+            };
+            hunks.push(hunk);
+            oldRangeStart = 0;
+            newRangeStart = 0;
+            curRange = [];
+          }
+        }
+        oldLine += lines.length;
+        newLine += lines.length;
+      }
+    }
+    for (const hunk of hunks) {
+      for (let i = 0; i < hunk.lines.length; i++) {
+        if (hunk.lines[i].endsWith("\n")) {
+          hunk.lines[i] = hunk.lines[i].slice(0, -1);
+        } else {
+          hunk.lines.splice(i + 1, 0, "\");
+          i++;
+        }
+      }
+    }
+    return {
+      oldFileName,
+      newFileName,
+      oldHeader,
+      newHeader,
+      hunks
+    };
+  }
+}
+function formatPatch(patch, headerOptions) {
+  var _a, _b, _c, _d, _e, _f;
+  if (!headerOptions) {
+    headerOptions = INCLUDE_HEADERS;
+  }
+  if (Array.isArray(patch)) {
+    if (patch.length > 1 && !headerOptions.includeFileHeaders && !patch.every((p) => p.isGit)) {
+      throw new Error("Cannot omit file headers on a multi-file patch. (The result would be unparseable; how would a tool trying to apply the patch know which changes are to which file?)");
+    }
+    return patch.map((p) => formatPatch(p, headerOptions)).join("\n");
+  }
+  const ret = [];
+  if (patch.isGit) {
+    headerOptions = INCLUDE_HEADERS;
+    if (!patch.oldFileName) {
+      throw new Error("oldFileName must be specified for Git patches");
+    }
+    if (!patch.newFileName) {
+      throw new Error("newFileName must be specified for Git patches");
+    }
+    let gitOldName = patch.oldFileName;
+    let gitNewName = patch.newFileName;
+    if (patch.isCreate && gitOldName === "/dev/null") {
+      gitOldName = gitNewName.replace(/^b\//, "a/");
+    } else if (patch.isDelete && gitNewName === "/dev/null") {
+      gitNewName = gitOldName.replace(/^a\//, "b/");
+    }
+    ret.push("diff --git " + quoteFileNameIfNeeded(gitOldName) + " " + quoteFileNameIfNeeded(gitNewName));
+    if (patch.isDelete) {
+      ret.push("deleted file mode " + ((_a = patch.oldMode) !== null && _a !== void 0 ? _a : "100644"));
+    }
+    if (patch.isCreate) {
+      ret.push("new file mode " + ((_b = patch.newMode) !== null && _b !== void 0 ? _b : "100644"));
+    }
+    if (patch.oldMode && patch.newMode && !patch.isDelete && !patch.isCreate) {
+      ret.push("old mode " + patch.oldMode);
+      ret.push("new mode " + patch.newMode);
+    }
+    if (patch.isRename) {
+      ret.push("rename from " + quoteFileNameIfNeeded(((_c = patch.oldFileName) !== null && _c !== void 0 ? _c : "").replace(/^a\//, "")));
+      ret.push("rename to " + quoteFileNameIfNeeded(((_d = patch.newFileName) !== null && _d !== void 0 ? _d : "").replace(/^b\//, "")));
+    }
+    if (patch.isCopy) {
+      ret.push("copy from " + quoteFileNameIfNeeded(((_e = patch.oldFileName) !== null && _e !== void 0 ? _e : "").replace(/^a\//, "")));
+      ret.push("copy to " + quoteFileNameIfNeeded(((_f = patch.newFileName) !== null && _f !== void 0 ? _f : "").replace(/^b\//, "")));
+    }
+  } else {
+    if (headerOptions.includeIndex && patch.oldFileName == patch.newFileName && patch.oldFileName !== void 0) {
+      ret.push("Index: " + patch.oldFileName);
+    }
+    if (headerOptions.includeUnderline) {
+      ret.push("===================================================================");
+    }
+  }
+  const hasHunks = patch.hunks.length > 0;
+  if (headerOptions.includeFileHeaders && patch.oldFileName !== void 0 && patch.newFileName !== void 0 && (!patch.isGit || hasHunks)) {
+    ret.push("--- " + quoteFileNameIfNeeded(patch.oldFileName) + (patch.oldHeader ? "	" + patch.oldHeader : ""));
+    ret.push("+++ " + quoteFileNameIfNeeded(patch.newFileName) + (patch.newHeader ? "	" + patch.newHeader : ""));
+  }
+  for (let i = 0; i < patch.hunks.length; i++) {
+    const hunk = patch.hunks[i];
+    const oldStart = hunk.oldLines === 0 ? hunk.oldStart - 1 : hunk.oldStart;
+    const newStart = hunk.newLines === 0 ? hunk.newStart - 1 : hunk.newStart;
+    ret.push("@@ -" + oldStart + "," + hunk.oldLines + " +" + newStart + "," + hunk.newLines + " @@");
+    for (const line of hunk.lines) {
+      ret.push(line);
+    }
+  }
+  return ret.join("\n") + "\n";
+}
+function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
+  if (typeof options === "function") {
+    options = { callback: options };
+  }
+  if (!(options === null || options === void 0 ? void 0 : options.callback)) {
+    const patchObj = structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options);
+    if (!patchObj) {
+      return;
+    }
+    return formatPatch(patchObj, options === null || options === void 0 ? void 0 : options.headerOptions);
+  } else {
+    const { callback } = options;
+    structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, Object.assign(Object.assign({}, options), { callback: (patchObj) => {
+      if (!patchObj) {
+        callback(void 0);
+      } else {
+        callback(formatPatch(patchObj, options.headerOptions));
+      }
+    } }));
+  }
+}
+function splitLines(text) {
+  const hasTrailingNl = text.endsWith("\n");
+  const result = text.split("\n").map((line) => line + "\n");
+  if (hasTrailingNl) {
+    result.pop();
+  } else {
+    result.push(result.pop().slice(0, -1));
+  }
+  return result;
+}
+
+// src/integrate.ts
+import { readFile, lstat, writeFile } from "node:fs/promises";
+import { join, relative, dirname, resolve } from "node:path";
+var dummy = { workspaceId: "YOUR_WORKSPACE_ID", siteId: "YOUR_SITE_ID", apiBaseUrl: "https://api.userreason.com" };
+async function source(project, path) {
+  const rel = relative(project.directory, path);
+  if (rel.startsWith("..") || rel === "") throw new Error("Application entry must stay inside the project");
+  let current = project.directory;
+  for (const part of rel.split("/")) {
+    current = join(current, part);
+    let entry;
+    try {
+      entry = await lstat(current);
+    } catch (error) {
+      if (error.code === "ENOENT") return;
+      throw error;
+    }
+    if (entry.isSymbolicLink()) throw new Error(`Refusing a symlinked application path: ${rel}`);
+  }
+  const info = await lstat(path);
+  if (!info.isFile() || info.size > 2e6)
+    throw new Error("Application entry must be a regular file under 2 MB");
+  return readFile(path, "utf8");
+}
+function parse(path, text) {
+  const ast = import_typescript.default.createSourceFile(
+    path,
+    text,
+    import_typescript.default.ScriptTarget.Latest,
+    true,
+    /\.(?:jsx?|tsx)$/.test(path) ? import_typescript.default.ScriptKind.TSX : import_typescript.default.ScriptKind.TS
+  );
+  if (ast.parseDiagnostics?.length)
+    return;
+  return ast;
+}
+function nodes(ast, test) {
+  const result = [];
+  const visit = (node) => {
+    if (test(node)) result.push(node);
+    import_typescript.default.forEachChild(node, visit);
+  };
+  visit(ast);
+  return result;
+}
+function sdkCalls(ast) {
+  const bindings = new Set(ast.statements.filter(import_typescript.default.isImportDeclaration).filter((node) => import_typescript.default.isStringLiteral(node.moduleSpecifier) && node.moduleSpecifier.text === "@userreason/js").map((node) => node.importClause?.name?.text).filter((value) => Boolean(value)));
+  return nodes(ast, import_typescript.default.isCallExpression).filter((call) => import_typescript.default.isPropertyAccessExpression(call.expression) && call.expression.name.text === "init" && bindings.has(call.expression.expression.getText(ast)));
+}
+function literalInstallation(call) {
+  const options = call.arguments[0];
+  if (!options || !import_typescript.default.isObjectLiteralExpression(options)) throw new Error("Existing UserReason options are dynamic. Supply --workspace and --site to select this installation explicitly.");
+  const values = {};
+  for (const property of options.properties) {
+    if (import_typescript.default.isSpreadAssignment(property)) throw new Error("Existing UserReason options use a spread. Supply --workspace and --site.");
+    if (!import_typescript.default.isPropertyAssignment(property)) continue;
+    const name = import_typescript.default.isIdentifier(property.name) || import_typescript.default.isStringLiteral(property.name) ? property.name.text : "";
+    if (!["siteId", "workspaceId", "apiBaseUrl"].includes(name)) continue;
+    if (!import_typescript.default.isStringLiteral(property.initializer)) throw new Error("Existing UserReason configuration uses variables. Supply --workspace and --site.");
+    values[name] = property.initializer.text;
+  }
+  if (!values.siteId) return;
+  return { siteId: values.siteId, apiBaseUrl: values.apiBaseUrl ?? DEFAULT_API, ...values.workspaceId ? { workspaceId: values.workspaceId } : {} };
+}
+async function scanInstallation(project) {
+  const candidates = /* @__PURE__ */ new Set();
+  for (const folder of ["", "src/"]) {
+    for (const name of ["main", "index", "instrumentation-client", "userreason.client", "userreason.generated"]) {
+      for (const extension of ["ts", "tsx", "js", "jsx"]) candidates.add(`${folder}${name}.${extension}`);
+    }
+  }
+  if (project.framework === "vanilla") {
+    const html = await source(project, join(project.directory, "index.html"));
+    for (const match of html?.matchAll(/<script\b([^>]*)>/gi) ?? []) {
+      const src = /\bsrc\s*=\s*['"]([^'"]+)['"]/i.exec(match[1])?.[1];
+      if (src && /\btype\s*=\s*['"]module['"]/i.test(match[1]) && !/^(?:[a-z]+:|\/\/)|[?#]/i.test(src)) candidates.add(src.replace(/^\//, ""));
+    }
+  }
+  let found;
+  for (const candidate of candidates) {
+    const path = resolve(project.directory, candidate), text = await source(project, path);
+    if (!text) continue;
+    const ast = parse(path, text);
+    if (!ast) continue;
+    for (const call of sdkCalls(ast)) {
+      const config = literalInstallation(call);
+      if (!config) continue;
+      if (found && (found.config.siteId !== config.siteId || found.config.apiBaseUrl !== config.apiBaseUrl)) throw new Error("Multiple UserReason installations found. Supply --workspace and --site.");
+      found = { config, path };
+    }
+  }
+  return found;
+}
+async function detectInstallation(project) {
+  return (await scanInstallation(project))?.config;
+}
+async function initializationPath(project) {
+  return (await scanInstallation(project))?.path;
+}
+function importStatement(project, path, name) {
+  const helper = join(
+    project.sourceDirectory,
+    integrationSource(project.framework, dummy, project.typescript, true).filename
+  );
+  let specifier = relative(dirname(path), helper).replaceAll("\\", "/");
+  if (project.framework !== "vanilla") specifier = specifier.replace(/\.[jt]sx?$/, "");
+  if (!specifier.startsWith(".")) specifier = "./" + specifier;
+  return `import { ${name} } from '${specifier}';`;
+}
+function insertImport(ast, text, statement) {
+  let position = ast.statements[0]?.getStart(ast) ?? 0;
+  for (const node of ast.statements) {
+    if (import_typescript.default.isImportDeclaration(node) || import_typescript.default.isExpressionStatement(node) && import_typescript.default.isStringLiteral(node.expression))
+      position = node.end;
+    else break;
+  }
+  return text.slice(0, position) + (position ? "\n" : "") + statement + "\n" + text.slice(position);
+}
+function wrap(text, node, ast) {
+  return text.slice(0, node.getStart(ast)) + `<><UserReasonInit />${node.getText(ast)}</>` + text.slice(node.end);
+}
+function importedBindings(ast) {
+  const dom = /* @__PURE__ */ new Set(), factories = /* @__PURE__ */ new Set();
+  for (const node of ast.statements) {
+    if (!import_typescript.default.isImportDeclaration(node) || !import_typescript.default.isStringLiteral(node.moduleSpecifier) || !["react-dom", "react-dom/client"].includes(node.moduleSpecifier.text))
+      continue;
+    if (node.importClause?.name) dom.add(node.importClause.name.text);
+    const bindings = node.importClause?.namedBindings;
+    if (bindings && import_typescript.default.isNamespaceImport(bindings)) dom.add(bindings.name.text);
+    if (bindings && import_typescript.default.isNamedImports(bindings)) {
+      for (const item of bindings.elements)
+        if ((item.propertyName ?? item.name).text === "createRoot") factories.add(item.name.text);
+    }
+  }
+  return { dom, factories };
+}
+function reactRoots(ast) {
+  const { dom, factories } = importedBindings(ast);
+  const createRoot = (node) => import_typescript.default.isCallExpression(node) && (import_typescript.default.isIdentifier(node.expression) && factories.has(node.expression.text) || import_typescript.default.isPropertyAccessExpression(node.expression) && import_typescript.default.isIdentifier(node.expression.expression) && dom.has(node.expression.expression.text) && node.expression.name.text === "createRoot");
+  const creationCount = nodes(ast, import_typescript.default.isCallExpression).filter(createRoot).length;
+  const roots = new Set(
+    nodes(ast, import_typescript.default.isVariableDeclaration).filter((node) => node.initializer && createRoot(node.initializer) && import_typescript.default.isIdentifier(node.name)).map((node) => node.name.getText(ast))
+  );
+  const renders = nodes(ast, import_typescript.default.isCallExpression).filter((node) => {
+    const member = node.expression;
+    return import_typescript.default.isPropertyAccessExpression(member) && member.name.text === "render" && (createRoot(member.expression) || import_typescript.default.isIdentifier(member.expression) && (roots.has(member.expression.text) || !creationCount && dom.has(member.expression.text)));
+  });
+  if (!creationCount && renders.length > 1) return [];
+  return renders.flatMap((node) => node.arguments[0] ? [node.arguments[0]] : []);
+}
+function integrationReferences(ast) {
+  const modules = nodes(ast, import_typescript.default.isStringLiteral).filter((literal) => {
+    const parent = literal.parent;
+    return (import_typescript.default.isImportDeclaration(parent) || import_typescript.default.isExportDeclaration(parent)) && parent.moduleSpecifier === literal || import_typescript.default.isExternalModuleReference(parent) && parent.expression === literal || import_typescript.default.isCallExpression(parent) && parent.arguments[0] === literal && (parent.expression.kind === import_typescript.default.SyntaxKind.ImportKeyword || import_typescript.default.isIdentifier(parent.expression) && parent.expression.text === "require");
+  }).map((literal) => literal.text);
+  const tags = nodes(ast, (node) => import_typescript.default.isJsxOpeningElement(node) || import_typescript.default.isJsxSelfClosingElement(node)).map((node) => node.tagName.getText(ast));
+  const globalAccess = nodes(ast, import_typescript.default.isElementAccessExpression).some((node) => import_typescript.default.isIdentifier(node.expression) && ["window", "globalThis", "self", "global"].includes(node.expression.text) && import_typescript.default.isStringLiteralLike(node.argumentExpression) && node.argumentExpression.text === "UserReason");
+  const identifier = nodes(ast, import_typescript.default.isIdentifier).some((node) => {
+    if (node.text !== "UserReason") return false;
+    const parent = node.parent;
+    if ((import_typescript.default.isPropertyAssignment(parent) || import_typescript.default.isPropertyDeclaration(parent) || import_typescript.default.isPropertySignature(parent) || import_typescript.default.isMethodDeclaration(parent) || import_typescript.default.isMethodSignature(parent) || import_typescript.default.isGetAccessorDeclaration(parent) || import_typescript.default.isSetAccessorDeclaration(parent) || import_typescript.default.isJsxAttribute(parent)) && parent.name === node) return false;
+    if ((import_typescript.default.isBindingElement(parent) || import_typescript.default.isImportSpecifier(parent)) && parent.propertyName === node) return false;
+    if (import_typescript.default.isExportSpecifier(parent) && parent.name === node && parent.propertyName) return false;
+    if (import_typescript.default.isLabeledStatement(parent) || import_typescript.default.isBreakStatement(parent) || import_typescript.default.isContinueStatement(parent)) return false;
+    return true;
+  });
+  return { modules, tags, identifier: identifier || globalAccess };
+}
+function existing(text, config = dummy, path = "entry.tsx") {
+  const ast = parse(path, text), calls = ast ? sdkCalls(ast) : [];
+  if (calls.length) {
+    try {
+      let first;
+      for (const call of calls) {
+        const options = literalInstallation(call);
+        if (!options) return { status: "manual", reason: "Existing SDK initialization configuration needs review." };
+        if (first && (options.siteId !== first.siteId || options.apiBaseUrl !== first.apiBaseUrl) || config !== dummy && (options.workspaceId !== void 0 && config.workspaceId !== void 0 && options.workspaceId !== config.workspaceId || options.siteId !== config.siteId || options.apiBaseUrl !== config.apiBaseUrl))
+          return { status: "manual", reason: "Existing SDK initialization targets a different site or API. Review it before replacing its configuration." };
+        first = options;
+      }
+    } catch {
+      return { status: "manual", reason: "Existing SDK initialization configuration needs review." };
+    }
+    return { status: "integrated", reason: "SDK initialization is already present; its configuration is preserved." };
+  }
+  if (!ast) return;
+  const references = integrationReferences(ast);
+  if (references.modules.some((name) => /userreason\.generated/.test(name)) && references.tags.includes("UserReasonProvider"))
+    return { status: "integrated", reason: "Existing generated initialization is already present." };
+  if (references.modules.some((name) => /userreason\.client/.test(name)) && references.tags.includes("UserReasonInit"))
+    return { status: "integrated", reason: "Browser initialization is already present." };
+  if (references.identifier || references.modules.some((name) => name === "@userreason/js" || /userreason\.(?:generated|client)/.test(name)))
+    return { status: "manual", reason: "An existing UserReason integration needs review before editing the entry." };
+}
+async function planIntegration(project, config = dummy) {
+  if (project.framework === "next" && project.nextInstrumentation) {
+    let directory = project.sourceDirectory;
+    for (const folder of ["app", "pages"]) {
+      try {
+        const entry = await lstat(join(project.directory, folder));
+        if (entry.isSymbolicLink()) throw new Error("Refusing a symlinked Next application directory");
+        if (entry.isDirectory()) directory = project.directory;
+      } catch (error) {
+        if (error.code !== "ENOENT") throw error;
+      }
+    }
+    const files = await Promise.all(["ts", "js"].map(async (extension) => {
+      const path3 = join(directory, `instrumentation-client.${extension}`);
+      return { path: path3, text: await source(project, path3) };
+    }));
+    const found2 = files.filter((value) => value.text !== void 0);
+    if (found2.length > 1) return { status: "manual", reason: "Multiple instrumentation-client files need review." };
+    for (const root of ["app/layout.tsx", "app/layout.jsx", "app/layout.js", "pages/_app.tsx", "pages/_app.jsx", "pages/_app.js"]) {
+      const rootPath = join(directory, root), rootText = await source(project, rootPath);
+      const rootAst = rootText ? parse(rootPath, rootText) : void 0;
+      if (rootText && rootAst && integrationReferences(rootAst).modules.some((name2) => /userreason\.(?:generated|client)/.test(name2)))
+        return existing(rootText, dummy, rootPath) ?? { status: "manual", reason: "Existing root initialization needs review." };
+    }
+    const { path: path2, text: text2 } = found2[0] ?? files[project.typescript ? 0 : 1];
+    const current2 = text2 ? existing(text2, config, path2) : void 0;
+    if (current2) return current2;
+    const ast = parse(path2, text2 ?? "");
+    if (!ast) return { status: "manual", reason: "Client instrumentation could not be parsed safely." };
+    return {
+      status: "ready",
+      directory: project.directory,
+      path: path2,
+      before: text2 ?? null,
+      after: insertImport(ast, text2 ?? "", `import UserReason from '@userreason/js';
+
+${initializationSource(config)}`),
+      description: `Initialize UserReason in ${relative(project.directory, path2)}`
+    };
+  }
+  const candidates = project.framework === "next" ? [
+    "app/layout.tsx",
+    "app/layout.jsx",
+    "app/layout.js",
+    "src/app/layout.tsx",
+    "src/app/layout.jsx",
+    "src/app/layout.js",
+    "pages/_app.tsx",
+    "pages/_app.jsx",
+    "pages/_app.js",
+    "src/pages/_app.tsx",
+    "src/pages/_app.jsx",
+    "src/pages/_app.js"
+  ] : project.framework === "vue" ? ["src/main.ts", "src/main.js", "main.ts", "main.js"] : project.framework === "react" ? [
+    "src/main.tsx",
+    "src/main.jsx",
+    "src/index.tsx",
+    "src/index.jsx",
+    "src/index.js",
+    "src/main.js",
+    "index.jsx"
+  ] : [];
+  if (project.framework === "vanilla") {
+    const html = await source(project, join(project.directory, "index.html"));
+    if (html) {
+      const scripts = [...html.matchAll(/<script\b([^>]*)>/gi)].filter((match) => /\btype\s*=\s*['"]module['"]/i.test(match[1])).map((match) => /\bsrc\s*=\s*['"]([^'"]+)['"]/i.exec(match[1])?.[1]).filter((value) => Boolean(value) && !/^(?:[a-z]+:|\/\/)|[?#]/i.test(value));
+      if (scripts.length === 1) candidates.push(scripts[0].replace(/^\//, ""));
+    }
+  }
+  const found = [];
+  for (const candidate of candidates) {
+    const path2 = resolve(project.directory, candidate), text2 = await source(project, path2);
+    if (text2 !== void 0) found.push({ path: path2, text: text2 });
+  }
+  if (found.length !== 1)
+    return {
+      status: "manual",
+      reason: found.length ? "More than one application entry was found. Choose the root and follow the generated integration instructions." : "The application root could not be identified. Follow the generated integration instructions."
+    };
+  const { path, text } = found[0];
+  const name = project.framework === "next" ? "UserReasonInit" : "UserReason";
+  const current = existing(text, config, path);
+  if (current) return current;
+  let after;
+  {
+    const ast = parse(path, text);
+    if (!ast) return { status: "manual", reason: "The application entry could not be parsed safely." };
+    if (project.framework !== "next") {
+      if (project.framework === "react" && !reactRoots(ast).length)
+        return { status: "manual", reason: "The browser entry needs one recognizable React application root." };
+      if (project.framework === "vue" && !/\bcreateApp\s*\(/.test(text))
+        return { status: "manual", reason: "The Vue entry needs a recognizable createApp call." };
+      after = insertImport(ast, text, `import UserReason from '@userreason/js';
+
+${initializationSource(config)}`);
+    } else if (project.framework === "next" && /[/\\]app[/\\]layout\./.test(path)) {
+      const bodies = nodes(ast, import_typescript.default.isJsxElement).filter(
+        (node) => node.openingElement.tagName.getText(ast) === "body"
+      );
+      if (bodies.length !== 1)
+        return { status: "manual", reason: "The Next.js root layout needs one recognizable <body> element." };
+      const position = bodies[0].openingElement.end;
+      after = text.slice(0, position) + "\n<UserReasonInit />" + text.slice(position);
+      after = insertImport(ast, after, importStatement(project, path, name));
+    } else {
+      let roots;
+      {
+        const exports = nodes(ast, import_typescript.default.isFunctionDeclaration).filter(
+          (node) => node.modifiers?.some((modifier) => modifier.kind === import_typescript.default.SyntaxKind.DefaultKeyword)
+        );
+        const returns = exports.length === 1 ? nodes(exports[0], import_typescript.default.isReturnStatement).filter((node) => node.expression) : [];
+        roots = returns.length === 1 && returns[0]?.expression ? [returns[0].expression] : [];
+      }
+      roots = roots.map((root) => import_typescript.default.isParenthesizedExpression(root) ? root.expression : root);
+      if (!roots.length || roots.some(
+        (root) => !(import_typescript.default.isJsxElement(root) || import_typescript.default.isJsxSelfClosingElement(root) || import_typescript.default.isJsxFragment(root))
+      ))
+        return {
+          status: "manual",
+          reason: "Automatic integration needs recognizable JSX renders on one application root."
+        };
+      after = text;
+      for (const root of roots.sort((left, right) => right.pos - left.pos)) after = wrap(after, root, ast);
+      after = insertImport(ast, after, importStatement(project, path, name));
+    }
+  }
+  return {
+    status: "ready",
+    directory: project.directory,
+    path,
+    before: text,
+    after,
+    description: `Add ${name} initialization to ${relative(project.directory, path)}`,
+    legacyNext: project.framework === "next"
+  };
+}
+async function applyIntegration(plan) {
+  if (plan.status !== "ready") return void 0;
+  if (plan.before === null) {
+    if (await source({ directory: plan.directory }, plan.path) !== void 0)
+      throw new Error("The client instrumentation entry changed after the preview. Rerun to review it again.");
+    await writeFile(plan.path, plan.after, { flag: "wx", mode: 420 });
+    return void 0;
+  }
+  const info = await lstat(plan.path);
+  if (!info.isFile() || info.isSymbolicLink() || await source({ directory: plan.directory }, plan.path) !== plan.before)
+    throw new Error("The application entry changed after the preview. Rerun to review it again.");
+  await writeFile(plan.path, plan.after);
+}
+function integrationPreview(plan) {
+  if (plan.status !== "ready") return plan.reason;
+  const path = relative(plan.directory, plan.path);
+  return createTwoFilesPatch(path, path, plan.before ?? "", plan.after, "", "", { context: 1 }).trim();
+}
+function integrationAdditions(plan) {
+  if (plan.status !== "ready") return void 0;
+  const added = [];
+  let line = 0, cursor = 0;
+  for (const part of diffLines(plan.before ?? "", plan.after)) {
+    if (part.removed) continue;
+    if (part.added) {
+      const lines = part.value.split("\n");
+      if (lines[lines.length - 1] === "") lines.pop();
+      const shown = lines.filter((value) => value.trim());
+      if (shown.length && !line) line = cursor + 1 + lines.findIndex((value) => value.trim());
+      added.push(...shown);
+    }
+    cursor += part.count ?? 0;
+  }
+  return { path: relative(plan.directory, plan.path), line, added, created: plan.before === null };
+}
+
+export {
+  detectInstallation,
+  initializationPath,
+  planIntegration,
+  applyIntegration,
+  integrationPreview,
+  integrationAdditions
+};