@aaqiljamal/visual-editor-server 0.2.0

package/dist/chunk-QEI2RGE2.js

@@ -0,0 +1,1584 @@
+// src/fs/applyToFile.ts
+import * as fs from "fs/promises";
+import { createPatch } from "diff";
+
+// src/ast/className.ts
+import * as recast from "recast";
+import babelTsParser from "recast/parsers/babel-ts.js";
+import { twMerge } from "tailwind-merge";
+var KNOWN_MERGERS = /* @__PURE__ */ new Set([
+  "cn",
+  "clsx",
+  "classnames",
+  "twMerge",
+  "twJoin"
+]);
+function mutateClassName(input) {
+  const { source, line, col, before, after } = input;
+  let ast;
+  try {
+    ast = recast.parse(source, { parser: babelTsParser });
+  } catch (err) {
+    return {
+      ok: false,
+      reason: "dynamic-other",
+      details: `parse error: ${err.message}`
+    };
+  }
+  const out = {
+    value: null,
+    visited: false
+  };
+  recast.visit(ast, {
+    visitJSXOpeningElement(path4) {
+      const node = path4.node;
+      const loc = node.loc;
+      if (!loc) {
+        this.traverse(path4);
+        return void 0;
+      }
+      if (loc.start.line !== line || loc.start.column !== col) {
+        this.traverse(path4);
+        return void 0;
+      }
+      out.visited = true;
+      out.value = mutateOnNode(node, before, after);
+      return false;
+    }
+  });
+  if (!out.visited) {
+    return {
+      ok: false,
+      reason: "no-jsx-at-location",
+      details: `No JSXOpeningElement found at ${line}:${col}`
+    };
+  }
+  if (!out.value) {
+    return {
+      ok: false,
+      reason: "dynamic-other",
+      details: "Internal: visitor matched but produced no result"
+    };
+  }
+  if (out.value.ok) {
+    return { ok: true, output: recast.print(ast).code };
+  }
+  return out.value;
+}
+function mutateOnNode(node, before, after) {
+  const open = node;
+  const attrs = open.attributes ?? [];
+  const classNameAttr = attrs.find(
+    (a) => a.type === "JSXAttribute" && a.name?.type === "JSXIdentifier" && a.name?.name === "className"
+  );
+  if (!classNameAttr) {
+    return {
+      ok: false,
+      reason: "no-classname-attribute",
+      details: "JSX element has no className attribute (possibly composed via {...spread} or passed as a prop)"
+    };
+  }
+  const value = classNameAttr.value;
+  if (!value) {
+    return {
+      ok: false,
+      reason: "no-classname-attribute",
+      details: "className attribute has no value"
+    };
+  }
+  if (value.type === "StringLiteral" || value.type === "Literal") {
+    const lit = value;
+    return swapAndReturn(lit, before, after);
+  }
+  if (value.type === "JSXExpressionContainer") {
+    const ec = value;
+    return mutateOnExpression(ec.expression, before, after);
+  }
+  return {
+    ok: false,
+    reason: "dynamic-other",
+    details: `className uses unsupported value node type: ${value.type}`
+  };
+}
+function mutateOnExpression(expr, before, after) {
+  if (expr.type === "StringLiteral" || expr.type === "Literal") {
+    const lit = expr;
+    return swapAndReturn(lit, before, after);
+  }
+  if (expr.type === "TemplateLiteral") {
+    return {
+      ok: false,
+      reason: "dynamic-template-literal",
+      details: "className uses a template literal; v0.1 only mutates static string literals at the source location"
+    };
+  }
+  if (expr.type === "CallExpression") {
+    return mutateOnCallExpression(expr, before, after);
+  }
+  if (expr.type === "ConditionalExpression") {
+    return {
+      ok: false,
+      reason: "dynamic-conditional",
+      details: "className uses a conditional (ternary) expression; v0.1 only mutates static string literals"
+    };
+  }
+  return {
+    ok: false,
+    reason: "dynamic-other",
+    details: `className uses unsupported expression type: ${expr.type}`
+  };
+}
+function swapAndReturn(lit, before, after) {
+  const swapped = swapToken(lit.value, before, after);
+  if (swapped === null) {
+    return {
+      ok: false,
+      reason: "token-not-found",
+      details: `Token "${before}" not found in className value "${lit.value}"`
+    };
+  }
+  lit.value = swapped;
+  if (lit.extra) lit.extra = void 0;
+  return { ok: true, output: "" };
+}
+function mutateOnCallExpression(call, before, after) {
+  const calleeName = getCalleeName(call.callee);
+  if (!calleeName || !KNOWN_MERGERS.has(calleeName)) {
+    return {
+      ok: false,
+      reason: "unknown-merger",
+      details: `className uses ${calleeName ?? "(call)"}(...). v0.2 only mutates inside known classname mergers: ${[...KNOWN_MERGERS].join(", ")}.`
+    };
+  }
+  const args = call.arguments ?? [];
+  let targetIdx = -1;
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a && (a.type === "StringLiteral" || a.type === "Literal") && typeof a.value === "string" && tokensFromValue(a.value).includes(before)) {
+      targetIdx = i;
+      break;
+    }
+  }
+  if (targetIdx === -1) {
+    return {
+      ok: false,
+      reason: "token-not-found",
+      details: `Token "${before}" not present in any static string argument of ${calleeName}(...)`
+    };
+  }
+  for (let i = 0; i < args.length; i++) {
+    if (i === targetIdx) continue;
+    const a = args[i];
+    if (!a) continue;
+    if (a.type === "StringLiteral" || a.type === "Literal") continue;
+    if (a.type === "SpreadElement") {
+      return {
+        ok: false,
+        reason: "dynamic-spread-arg",
+        details: `Argument ${i} of ${calleeName}() is a spread. v0.2 cannot analyze spread contents \u2014 refuse to mutate.`
+      };
+    }
+    return {
+      ok: false,
+      reason: "dynamic-uncertain-arg",
+      details: `Argument ${i} of ${calleeName}() is ${a.type}. v0.2 refuses to mutate when any other argument is non-static.`
+    };
+  }
+  const targetArg = args[targetIdx];
+  const newTargetValue = swapToken(targetArg.value, before, after);
+  if (newTargetValue === null) {
+    return {
+      ok: false,
+      reason: "token-not-found",
+      details: `Internal: target arg matched but swap couldn't find "${before}"`
+    };
+  }
+  const concatenated = args.map(
+    (a, i) => i === targetIdx ? newTargetValue : a.value ?? ""
+  ).join(" ").trim();
+  const mergedTokens = twMerge(concatenated).split(/\s+/).filter(Boolean);
+  const afterTokens = after.split(/\s+/).filter(Boolean);
+  for (const tok of afterTokens) {
+    if (!mergedTokens.includes(tok)) {
+      return {
+        ok: false,
+        reason: "dynamic-conflict",
+        details: `Mutation would be silently overridden: tailwind-merge resolves "${concatenated}" to "${mergedTokens.join(" ")}", which doesn't include "${tok}". A later argument wins.`
+      };
+    }
+  }
+  targetArg.value = newTargetValue;
+  if (targetArg.extra) targetArg.extra = void 0;
+  return { ok: true, output: "" };
+}
+function mutateAttribute(input) {
+  const { source, line, col, attribute, before, after } = input;
+  let ast;
+  try {
+    ast = recast.parse(source, { parser: babelTsParser });
+  } catch (err) {
+    return {
+      ok: false,
+      reason: "parse-error",
+      details: err.message
+    };
+  }
+  const out = { value: null, visited: false };
+  recast.visit(ast, {
+    visitJSXOpeningElement(path4) {
+      const node = path4.node;
+      const loc = node.loc;
+      if (!loc) {
+        this.traverse(path4);
+        return void 0;
+      }
+      if (loc.start.line !== line || loc.start.column !== col) {
+        this.traverse(path4);
+        return void 0;
+      }
+      out.visited = true;
+      const attrs = node.attributes ?? [];
+      const targetAttr = attrs.find(
+        (a) => a.type === "JSXAttribute" && a.name?.type === "JSXIdentifier" && a.name?.name === attribute
+      );
+      if (!targetAttr) {
+        out.value = {
+          ok: false,
+          reason: "no-such-attribute",
+          details: `JSX element has no \`${attribute}\` attribute`
+        };
+        return false;
+      }
+      const v = targetAttr.value;
+      if (!v) {
+        out.value = {
+          ok: false,
+          reason: "no-such-attribute",
+          details: `Attribute \`${attribute}\` has no value`
+        };
+        return false;
+      }
+      let lit = null;
+      if (v.type === "StringLiteral" || v.type === "Literal") {
+        lit = v;
+      } else if (v.type === "JSXExpressionContainer") {
+        const expr = v.expression;
+        if (expr.type === "StringLiteral" || expr.type === "Literal") {
+          lit = expr;
+        }
+      }
+      if (!lit) {
+        out.value = {
+          ok: false,
+          reason: "dynamic-value",
+          details: `Attribute \`${attribute}\` value is ${v.type}, not a static string literal`
+        };
+        return false;
+      }
+      if (before !== null && lit.value !== before) {
+        out.value = {
+          ok: false,
+          reason: "token-not-found",
+          details: `Current value "${lit.value}" doesn't match expected "${before}" \u2014 file may have changed externally`
+        };
+        return false;
+      }
+      const previousValue = lit.value;
+      lit.value = after;
+      if (lit.extra) lit.extra = void 0;
+      out.value = {
+        ok: true,
+        output: "",
+        previousValue
+      };
+      return false;
+    }
+  });
+  if (!out.visited) {
+    return {
+      ok: false,
+      reason: "no-jsx-at-location",
+      details: `No JSXOpeningElement found at ${line}:${col}`
+    };
+  }
+  if (!out.value) {
+    return {
+      ok: false,
+      reason: "no-jsx-at-location",
+      details: "Visitor matched location but produced no result"
+    };
+  }
+  if (out.value.ok) {
+    return {
+      ok: true,
+      output: recast.print(ast).code,
+      previousValue: out.value.previousValue
+    };
+  }
+  return out.value;
+}
+function getCalleeName(callee) {
+  if (!callee || typeof callee !== "object") return null;
+  const c = callee;
+  if (c.type === "Identifier") return c.name ?? null;
+  if (c.type === "MemberExpression") return c.property?.name ?? null;
+  return null;
+}
+function tokensFromValue(value) {
+  return value.split(/\s+/).filter(Boolean);
+}
+function swapToken(value, before, after) {
+  const parts = value.split(/(\s+)/);
+  let found = false;
+  const out = parts.map((p) => {
+    if (!found && p === before) {
+      found = true;
+      return after;
+    }
+    return p;
+  });
+  if (!found) return null;
+  return out.join("");
+}
+
+// src/fs/resolveSafe.ts
+import * as path from "path";
+function resolveWithinWorkspace(workspaceRoot, relativePath) {
+  if (typeof relativePath !== "string" || relativePath.length === 0) {
+    return null;
+  }
+  const root = path.resolve(workspaceRoot);
+  const candidate = path.resolve(root, relativePath);
+  if (candidate !== root && !candidate.startsWith(root + path.sep)) {
+    return null;
+  }
+  return candidate;
+}
+
+// src/fs/applyToFile.ts
+async function applyToFile(input, options) {
+  if (!isValidApplyInput(input)) {
+    return {
+      ok: false,
+      status: 400,
+      reason: "invalid-input",
+      details: "Body must be { file: string, line: number, col: number, before: string, after: string }"
+    };
+  }
+  const absolutePath = resolveWithinWorkspace(options.workspaceRoot, input.file);
+  if (!absolutePath) {
+    return {
+      ok: false,
+      status: 403,
+      reason: "path-outside-workspace",
+      details: `Refusing to touch path outside workspace root: ${input.file}`
+    };
+  }
+  let source;
+  try {
+    source = await fs.readFile(absolutePath, "utf8");
+  } catch (err) {
+    const e = err;
+    if (e.code === "ENOENT") {
+      return {
+        ok: false,
+        status: 404,
+        reason: "file-not-found",
+        details: `File not found: ${input.file}`
+      };
+    }
+    return {
+      ok: false,
+      status: 500,
+      reason: "read-failed",
+      details: `Failed to read ${input.file}: ${e.message}`
+    };
+  }
+  const attribute = input.attribute ?? "className";
+  const mutation = attribute === "className" ? mutateClassName({
+    source,
+    line: input.line,
+    col: input.col,
+    // mutateClassName requires before; reject if it's null
+    before: input.before ?? "",
+    after: input.after
+  }) : mutateAttribute({
+    source,
+    line: input.line,
+    col: input.col,
+    attribute,
+    before: input.before,
+    after: input.after
+  });
+  if (!mutation.ok) {
+    const status = mutation.reason === "token-not-found" ? 409 : 400;
+    return {
+      ok: false,
+      status,
+      reason: mutation.reason,
+      details: mutation.details
+    };
+  }
+  const diff = createPatch(input.file, source, mutation.output, "before", "after");
+  if (!options.dryRun) {
+    try {
+      await fs.writeFile(absolutePath, mutation.output, "utf8");
+    } catch (err) {
+      const e = err;
+      return {
+        ok: false,
+        status: 500,
+        reason: "write-failed",
+        details: `Failed to write ${input.file}: ${e.message}`
+      };
+    }
+  }
+  const previousValue = "previousValue" in mutation && typeof mutation.previousValue === "string" ? mutation.previousValue : input.before ?? void 0;
+  return { ok: true, diff, absolutePath, previousValue };
+}
+function isValidApplyInput(x) {
+  if (!x || typeof x !== "object") return false;
+  const o = x;
+  return typeof o.file === "string" && typeof o.line === "number" && typeof o.col === "number" && (typeof o.before === "string" || o.before === null) && typeof o.after === "string" && (o.attribute === void 0 || typeof o.attribute === "string") && Number.isInteger(o.line) && Number.isInteger(o.col) && o.line > 0 && o.col >= 0;
+}
+
+// src/fs/revertToFile.ts
+async function revertToFile(input, options, recent) {
+  const partial = input.file !== void 0 || input.line !== void 0 || input.col !== void 0;
+  const complete = typeof input.file === "string" && typeof input.line === "number" && typeof input.col === "number" && Number.isInteger(input.line) && Number.isInteger(input.col);
+  if (partial && !complete) {
+    return {
+      ok: false,
+      status: 400,
+      reason: "invalid-input",
+      details: "Either pass all of {file, line, col} or omit them to revert the most-recent apply."
+    };
+  }
+  const key = complete && typeof input.file === "string" && typeof input.line === "number" && typeof input.col === "number" ? { file: input.file, line: input.line, col: input.col } : void 0;
+  const entry = recent.find(key);
+  if (!entry) {
+    return {
+      ok: false,
+      status: 404,
+      reason: "no-recent-apply",
+      details: key ? `No recent apply found at ${key.file}:${key.line}:${key.col}` : "No recent applies to revert"
+    };
+  }
+  const outcome = await applyToFile(
+    {
+      file: entry.file,
+      line: entry.line,
+      col: entry.col,
+      before: entry.after,
+      // swap
+      after: entry.before
+    },
+    options
+  );
+  if (outcome.ok) {
+    recent.remove(entry);
+  }
+  return outcome;
+}
+
+// src/fs/applyCssProperty.ts
+import * as fs2 from "fs/promises";
+import * as path2 from "path";
+import { createPatch as createPatch2 } from "diff";
+
+// src/css/cssModule.ts
+import * as recast2 from "recast";
+import babelTsParser2 from "recast/parsers/babel-ts.js";
+import postcss from "postcss";
+function detectCssModule(jsxSource, line, col) {
+  let ast;
+  try {
+    ast = recast2.parse(jsxSource, { parser: babelTsParser2 });
+  } catch (err) {
+    return {
+      ok: false,
+      reason: "parse-error",
+      details: err.message
+    };
+  }
+  let found = { objectName: null, propertyName: null, visited: false };
+  recast2.visit(ast, {
+    visitJSXOpeningElement(path4) {
+      const node = path4.node;
+      const loc = node.loc;
+      if (!loc) {
+        this.traverse(path4);
+        return void 0;
+      }
+      if (loc.start.line !== line || loc.start.column !== col) {
+        this.traverse(path4);
+        return void 0;
+      }
+      found.visited = true;
+      const attrs = node.attributes ?? [];
+      const classNameAttr = attrs.find(
+        (a) => a.type === "JSXAttribute" && a.name?.type === "JSXIdentifier" && a.name?.name === "className"
+      );
+      if (!classNameAttr) return false;
+      const v = classNameAttr.value;
+      if (!v || v.type !== "JSXExpressionContainer") return false;
+      const expr = v.expression;
+      if (!expr) return false;
+      if (expr.type === "MemberExpression" && expr.computed === false && expr.object?.type === "Identifier" && expr.property?.type === "Identifier") {
+        found.objectName = expr.object.name ?? null;
+        found.propertyName = expr.property.name ?? null;
+      }
+      return false;
+    }
+  });
+  if (!found.visited) {
+    return {
+      ok: false,
+      reason: "no-jsx-at-location",
+      details: `No JSXOpeningElement found at ${line}:${col}`
+    };
+  }
+  if (!found.objectName) {
+    return {
+      ok: false,
+      reason: "dynamic-classname",
+      details: "className isn't a `{identifier.property}` member expression. B2 only handles direct `{styles.foo}` access."
+    };
+  }
+  const importHolder = { value: null };
+  recast2.visit(ast, {
+    visitImportDeclaration(path4) {
+      const node = path4.node;
+      const defaultSpec = node.specifiers.find(
+        (s) => s.type === "ImportDefaultSpecifier" && s.local?.name === found.objectName
+      );
+      if (defaultSpec) {
+        importHolder.value = node.source.value;
+        return false;
+      }
+      this.traverse(path4);
+      return void 0;
+    }
+  });
+  if (!importHolder.value) {
+    return {
+      ok: false,
+      reason: "unresolved-import",
+      details: `No default import found for \`${found.objectName}\``
+    };
+  }
+  const importSource = importHolder.value;
+  if (!importSource.endsWith(".module.css")) {
+    return {
+      ok: false,
+      reason: "not-a-css-module",
+      details: `Import \`${importSource}\` is not a .module.css file`
+    };
+  }
+  return {
+    ok: true,
+    ref: {
+      cssFile: importSource,
+      selector: `.${found.propertyName}`
+    }
+  };
+}
+function mutateCssProperty(cssSource, selector, property, value) {
+  if (!/^[a-zA-Z-]+$/.test(property)) {
+    return {
+      ok: false,
+      reason: "invalid-property",
+      details: `Property name "${property}" must be alphabetic + hyphens only`
+    };
+  }
+  let root;
+  try {
+    root = postcss.parse(cssSource);
+  } catch (err) {
+    return {
+      ok: false,
+      reason: "css-parse-error",
+      details: err.message
+    };
+  }
+  let targetRule = null;
+  root.walkRules((rule) => {
+    if (rule.selector === selector) {
+      targetRule = rule;
+      return false;
+    }
+  });
+  if (!targetRule) {
+    return {
+      ok: false,
+      reason: "selector-not-found",
+      details: `No rule matching selector \`${selector}\` in CSS source`
+    };
+  }
+  let hasComposes = false;
+  targetRule.walkDecls("composes", () => {
+    hasComposes = true;
+  });
+  if (hasComposes) {
+    return {
+      ok: false,
+      reason: "composes-chain",
+      details: `Rule \`${selector}\` uses \`composes:\`. v0.2 refuses to mutate composes chains because the property change could leak through.`
+    };
+  }
+  let previousValue = null;
+  let updated = false;
+  targetRule.walkDecls(property, (decl) => {
+    if (decl.parent !== targetRule) return;
+    if (!updated) {
+      previousValue = decl.value;
+      decl.value = value;
+      updated = true;
+    }
+  });
+  if (!updated) {
+    targetRule.append({ prop: property, value });
+  }
+  return {
+    ok: true,
+    output: root.toString(),
+    previousValue
+  };
+}
+
+// src/fs/applyCssProperty.ts
+async function applyCssProperty(input, options) {
+  if (!isValid(input)) {
+    return {
+      ok: false,
+      status: 400,
+      reason: "invalid-input",
+      details: "Body must be { file: string, line: number, col: number, property: string, value: string }"
+    };
+  }
+  const jsxAbs = resolveWithinWorkspace(options.workspaceRoot, input.file);
+  if (!jsxAbs) {
+    return {
+      ok: false,
+      status: 403,
+      reason: "path-outside-workspace",
+      details: `JSX file outside workspace: ${input.file}`
+    };
+  }
+  let jsxSource;
+  try {
+    jsxSource = await fs2.readFile(jsxAbs, "utf8");
+  } catch (err) {
+    const e = err;
+    if (e.code === "ENOENT") {
+      return {
+        ok: false,
+        status: 404,
+        reason: "jsx-file-not-found",
+        details: `JSX file not found: ${input.file}`
+      };
+    }
+    return {
+      ok: false,
+      status: 500,
+      reason: "read-failed",
+      details: `Read JSX failed: ${e.message}`
+    };
+  }
+  const detect = detectCssModule(jsxSource, input.line, input.col);
+  if (!detect.ok) {
+    return {
+      ok: false,
+      status: 400,
+      reason: detect.reason,
+      details: detect.details
+    };
+  }
+  const cssAbsolutePath = path2.resolve(
+    path2.dirname(jsxAbs),
+    detect.ref.cssFile
+  );
+  const cssRel = path2.relative(options.workspaceRoot, cssAbsolutePath);
+  if (cssRel.startsWith("..") || path2.isAbsolute(cssRel)) {
+    return {
+      ok: false,
+      status: 403,
+      reason: "path-outside-workspace",
+      details: `Resolved CSS file outside workspace: ${cssAbsolutePath}`
+    };
+  }
+  let cssSource;
+  try {
+    cssSource = await fs2.readFile(cssAbsolutePath, "utf8");
+  } catch (err) {
+    const e = err;
+    if (e.code === "ENOENT") {
+      return {
+        ok: false,
+        status: 404,
+        reason: "css-file-not-found",
+        details: `CSS file not found: ${cssAbsolutePath}`
+      };
+    }
+    return {
+      ok: false,
+      status: 500,
+      reason: "read-failed",
+      details: `Read CSS failed: ${e.message}`
+    };
+  }
+  const mutation = mutateCssProperty(
+    cssSource,
+    detect.ref.selector,
+    input.property,
+    input.value
+  );
+  if (!mutation.ok) {
+    return {
+      ok: false,
+      status: 400,
+      reason: mutation.reason,
+      details: mutation.details
+    };
+  }
+  const diff = createPatch2(cssRel, cssSource, mutation.output, "before", "after");
+  if (!options.dryRun) {
+    try {
+      await fs2.writeFile(cssAbsolutePath, mutation.output, "utf8");
+    } catch (err) {
+      const e = err;
+      return {
+        ok: false,
+        status: 500,
+        reason: "write-failed",
+        details: `Write CSS failed: ${e.message}`
+      };
+    }
+  }
+  return {
+    ok: true,
+    diff,
+    cssAbsolutePath,
+    selector: detect.ref.selector,
+    previousValue: mutation.previousValue
+  };
+}
+function isValid(x) {
+  if (!x || typeof x !== "object") return false;
+  const o = x;
+  return typeof o.file === "string" && typeof o.line === "number" && typeof o.col === "number" && typeof o.property === "string" && typeof o.value === "string" && Number.isInteger(o.line) && Number.isInteger(o.col) && o.line > 0 && o.col >= 0;
+}
+
+// src/fs/applyStyledProperty.ts
+import * as fs3 from "fs/promises";
+import { createPatch as createPatch3 } from "diff";
+
+// src/css/styledComponents.ts
+import * as recast3 from "recast";
+import babelTsParser3 from "recast/parsers/babel-ts.js";
+import postcss2 from "postcss";
+function detectStyledComponent(jsxSource, line, col) {
+  let ast;
+  try {
+    ast = recast3.parse(jsxSource, { parser: babelTsParser3 });
+  } catch (err) {
+    return {
+      ok: false,
+      reason: "parse-error",
+      details: err.message
+    };
+  }
+  const jsxFound = {
+    tagName: null,
+    visited: false
+  };
+  recast3.visit(ast, {
+    visitJSXOpeningElement(path4) {
+      const node = path4.node;
+      const loc = node.loc;
+      if (!loc) {
+        this.traverse(path4);
+        return void 0;
+      }
+      if (loc.start.line !== line || loc.start.column !== col) {
+        this.traverse(path4);
+        return void 0;
+      }
+      jsxFound.visited = true;
+      const name = node.name;
+      if (name.type === "JSXIdentifier" && name.name) {
+        jsxFound.tagName = name.name;
+      }
+      return false;
+    }
+  });
+  if (!jsxFound.visited) {
+    return {
+      ok: false,
+      reason: "no-jsx-at-location",
+      details: `No JSXOpeningElement found at ${line}:${col}`
+    };
+  }
+  if (!jsxFound.tagName || /^[a-z]/.test(jsxFound.tagName)) {
+    return {
+      ok: false,
+      reason: "not-a-styled-component",
+      details: `JSX tag is not a component identifier (got "${jsxFound.tagName ?? "<none>"}")`
+    };
+  }
+  let foundRef = null;
+  let refusedReason = null;
+  let refusedDetails = "";
+  const program = ast.program;
+  for (const stmt of program.body) {
+    if (stmt.type !== "VariableDeclaration") continue;
+    for (const decl of stmt.declarations ?? []) {
+      if (decl.type !== "VariableDeclarator") continue;
+      if (decl.id?.type !== "Identifier") continue;
+      if (decl.id.name !== jsxFound.tagName) continue;
+      const init = decl.init;
+      if (!init) continue;
+      if (init.type !== "TaggedTemplateExpression") {
+        refusedReason = "not-a-styled-component";
+        refusedDetails = `\`${jsxFound.tagName}\` is declared but isn't a tagged template`;
+        continue;
+      }
+      const tag = init.tag;
+      if (!tag) continue;
+      if (tag.type === "MemberExpression" && tag.computed === false && tag.object?.type === "Identifier" && tag.object.name === "styled" && tag.property?.type === "Identifier") {
+        if ((init.quasi?.expressions?.length ?? 0) > 0) {
+          refusedReason = "styled-with-interpolation";
+          refusedDetails = `\`${jsxFound.tagName}\` template has \${\u2026} interpolations \u2014 v0.2 only mutates fully-static templates`;
+          continue;
+        }
+        foundRef = {
+          componentName: jsxFound.tagName,
+          htmlTag: tag.property.name ?? "div"
+        };
+        break;
+      }
+      if (tag.type === "CallExpression") {
+        const callee = tag;
+        const c = callee.callee;
+        if (c?.type === "Identifier" && c.name === "styled") {
+          refusedReason = "styled-extension-not-supported";
+          refusedDetails = `\`styled(...)\` extension form \u2014 v0.2 only handles \`styled.tag\``;
+        } else if (c?.type === "MemberExpression" && c.property?.name === "attrs") {
+          refusedReason = "styled-attrs-not-supported";
+          refusedDetails = `\`.attrs(...)\` chain not supported in v0.2`;
+        }
+      }
+    }
+    if (foundRef) break;
+  }
+  if (foundRef) return { ok: true, ref: foundRef };
+  if (refusedReason) {
+    return {
+      ok: false,
+      reason: refusedReason,
+      details: refusedDetails
+    };
+  }
+  return {
+    ok: false,
+    reason: "cross-file-styled-not-supported",
+    details: `\`${jsxFound.tagName}\` isn't declared in this file. v0.2 only resolves same-file styled definitions.`
+  };
+}
+function mutateStyledProperty(jsxSource, componentName, property, value) {
+  if (!/^[a-zA-Z-]+$/.test(property)) {
+    return {
+      ok: false,
+      reason: "invalid-property",
+      details: `Property name "${property}" must be alphabetic + hyphens only`
+    };
+  }
+  let ast;
+  try {
+    ast = recast3.parse(jsxSource, { parser: babelTsParser3 });
+  } catch (err) {
+    return {
+      ok: false,
+      reason: "parse-error",
+      details: err.message
+    };
+  }
+  const out = {
+    found: false,
+    interpolated: false,
+    previousValue: null,
+    error: null
+  };
+  recast3.visit(ast, {
+    visitVariableDeclarator(path4) {
+      const node = path4.node;
+      if (out.found || out.error) return false;
+      if (node.id?.type !== "Identifier" || node.id.name !== componentName) {
+        this.traverse(path4);
+        return void 0;
+      }
+      const init = node.init;
+      if (!init || init.type !== "TaggedTemplateExpression") return false;
+      const tag = init.tag;
+      if (!tag || tag.type !== "MemberExpression" || tag.object?.type !== "Identifier" || tag.object.name !== "styled") {
+        return false;
+      }
+      const quasi = init.quasi;
+      if (!quasi) return false;
+      if ((quasi.expressions?.length ?? 0) > 0) {
+        out.interpolated = true;
+        out.error = {
+          reason: "styled-with-interpolation",
+          details: `\`${componentName}\` template has interpolations \u2014 v0.2 only mutates fully-static templates`
+        };
+        return false;
+      }
+      const onlyQuasi = quasi.quasis[0];
+      if (!onlyQuasi) return false;
+      const css = onlyQuasi.value.cooked ?? onlyQuasi.value.raw ?? "";
+      const wrapped = `:root {${css}}`;
+      let root;
+      try {
+        root = postcss2.parse(wrapped);
+      } catch (err) {
+        out.error = {
+          reason: "css-parse-error",
+          details: err.message
+        };
+        return false;
+      }
+      const rule = root.first;
+      if (!rule) {
+        out.error = {
+          reason: "css-parse-error",
+          details: "Internal: synthetic wrap produced no rule"
+        };
+        return false;
+      }
+      let updated = false;
+      rule.walkDecls(property, (decl) => {
+        if (decl.parent !== rule) return;
+        if (!updated) {
+          out.previousValue = decl.value;
+          decl.value = value;
+          updated = true;
+        }
+      });
+      if (!updated) {
+        rule.append({ prop: property, value });
+      }
+      const rebuilt = rule.toString();
+      const innerMatch = rebuilt.match(/^[^{]*\{([\s\S]*)\}\s*$/);
+      const inner = innerMatch && innerMatch[1] !== void 0 ? innerMatch[1] : rebuilt;
+      onlyQuasi.value.cooked = inner;
+      onlyQuasi.value.raw = inner;
+      out.found = true;
+      return false;
+    }
+  });
+  if (out.error) {
+    return { ok: false, ...out.error };
+  }
+  if (!out.found) {
+    return {
+      ok: false,
+      reason: "component-not-found",
+      details: `No \`const ${componentName} = styled.X\`\u2026\`\` definition found`
+    };
+  }
+  return {
+    ok: true,
+    output: recast3.print(ast).code,
+    previousValue: out.previousValue
+  };
+}
+
+// src/fs/applyStyledProperty.ts
+async function applyStyledProperty(input, options) {
+  if (!isValid2(input)) {
+    return {
+      ok: false,
+      status: 400,
+      reason: "invalid-input",
+      details: "Body must be { file: string, line: number, col: number, property: string, value: string }"
+    };
+  }
+  const absPath = resolveWithinWorkspace(options.workspaceRoot, input.file);
+  if (!absPath) {
+    return {
+      ok: false,
+      status: 403,
+      reason: "path-outside-workspace",
+      details: `File outside workspace: ${input.file}`
+    };
+  }
+  let source;
+  try {
+    source = await fs3.readFile(absPath, "utf8");
+  } catch (err) {
+    const e = err;
+    if (e.code === "ENOENT") {
+      return {
+        ok: false,
+        status: 404,
+        reason: "file-not-found",
+        details: `File not found: ${input.file}`
+      };
+    }
+    return {
+      ok: false,
+      status: 500,
+      reason: "read-failed",
+      details: `Read failed: ${e.message}`
+    };
+  }
+  const detect = detectStyledComponent(source, input.line, input.col);
+  if (!detect.ok) {
+    return {
+      ok: false,
+      status: 400,
+      reason: detect.reason,
+      details: detect.details
+    };
+  }
+  const mutation = mutateStyledProperty(
+    source,
+    detect.ref.componentName,
+    input.property,
+    input.value
+  );
+  if (!mutation.ok) {
+    return {
+      ok: false,
+      status: 400,
+      reason: mutation.reason,
+      details: mutation.details
+    };
+  }
+  const diff = createPatch3(input.file, source, mutation.output, "before", "after");
+  if (!options.dryRun) {
+    try {
+      await fs3.writeFile(absPath, mutation.output, "utf8");
+    } catch (err) {
+      const e = err;
+      return {
+        ok: false,
+        status: 500,
+        reason: "write-failed",
+        details: `Write failed: ${e.message}`
+      };
+    }
+  }
+  return {
+    ok: true,
+    diff,
+    componentName: detect.ref.componentName,
+    previousValue: mutation.previousValue
+  };
+}
+function isValid2(x) {
+  if (!x || typeof x !== "object") return false;
+  const o = x;
+  return typeof o.file === "string" && typeof o.line === "number" && typeof o.col === "number" && typeof o.property === "string" && typeof o.value === "string" && Number.isInteger(o.line) && Number.isInteger(o.col) && o.line > 0 && o.col >= 0;
+}
+
+// src/state/recentApplies.ts
+import * as fs4 from "fs/promises";
+var RecentApplies = class {
+  constructor(maxSize = 50) {
+    this.maxSize = maxSize;
+  }
+  maxSize;
+  buffer = [];
+  filePath = null;
+  /**
+   * Wire up disk persistence. If the file exists, its contents become the
+   * initial buffer. If it doesn't, we remember the path for future writes.
+   */
+  async load(filePath) {
+    this.filePath = filePath;
+    try {
+      const raw = await fs4.readFile(filePath, "utf8");
+      const parsed = JSON.parse(raw);
+      if (Array.isArray(parsed.applies)) {
+        this.buffer = parsed.applies.filter(isApply).slice(-this.maxSize);
+      }
+    } catch {
+    }
+  }
+  push(apply) {
+    this.buffer.push(apply);
+    if (this.buffer.length > this.maxSize) this.buffer.shift();
+    void this.persistNow();
+  }
+  /**
+   * Find the most-recent entry matching `key`. If no key is provided, returns
+   * the most-recent entry overall (single-step undo). Returns `null` when no
+   * matching entry is in the buffer.
+   */
+  find(key) {
+    if (this.buffer.length === 0) return null;
+    if (!key) return this.buffer[this.buffer.length - 1] ?? null;
+    for (let i = this.buffer.length - 1; i >= 0; i--) {
+      const a = this.buffer[i];
+      if (a && a.file === key.file && a.line === key.line && a.col === key.col) {
+        return a;
+      }
+    }
+    return null;
+  }
+  remove(apply) {
+    const idx = this.buffer.lastIndexOf(apply);
+    if (idx !== -1) this.buffer.splice(idx, 1);
+    void this.persistNow();
+  }
+  list() {
+    return this.buffer;
+  }
+  clear() {
+    this.buffer = [];
+    void this.persistNow();
+  }
+  get size() {
+    return this.buffer.length;
+  }
+  /**
+   * Write the buffer to disk. No-op when no path has been configured.
+   * Safe to `void`-call for fire-and-forget; tests can `await` it for
+   * determinism.
+   */
+  async persistNow() {
+    if (!this.filePath) return;
+    const json = JSON.stringify(
+      { applies: this.buffer, savedAt: Date.now() },
+      null,
+      2
+    );
+    try {
+      await fs4.writeFile(this.filePath, json, "utf8");
+    } catch {
+    }
+  }
+};
+function isApply(x) {
+  if (!x || typeof x !== "object") return false;
+  const o = x;
+  return typeof o.file === "string" && typeof o.line === "number" && typeof o.col === "number" && typeof o.before === "string" && typeof o.after === "string" && typeof o.appliedAt === "number";
+}
+
+// src/state/selection.ts
+var CurrentSelection = class {
+  current = null;
+  set(s) {
+    this.current = s;
+  }
+  get() {
+    return this.current;
+  }
+  clear() {
+    this.current = null;
+  }
+};
+
+// src/state/auth.ts
+import { randomBytes } from "crypto";
+import * as fs5 from "fs/promises";
+import * as path3 from "path";
+var SESSION_DIRNAME = ".visual-editor";
+var SESSION_FILENAME = "session.json";
+var SessionToken = class {
+  token = null;
+  filePath = null;
+  async load(workspaceRoot) {
+    const dir = path3.join(workspaceRoot, SESSION_DIRNAME);
+    this.filePath = path3.join(dir, SESSION_FILENAME);
+    try {
+      const existing = JSON.parse(
+        await fs5.readFile(this.filePath, "utf8")
+      );
+      if (typeof existing.token === "string" && existing.token.length >= 16) {
+        this.token = existing.token;
+        return this.token;
+      }
+    } catch {
+    }
+    await fs5.mkdir(dir, { recursive: true });
+    this.token = randomBytes(24).toString("hex");
+    await fs5.writeFile(
+      this.filePath,
+      JSON.stringify({ token: this.token, createdAt: Date.now() }, null, 2),
+      { encoding: "utf8", mode: 384 }
+    );
+    return this.token;
+  }
+  /** Construct the token in-process without touching disk. Used by tests. */
+  setInMemory(token) {
+    this.token = token;
+  }
+  get() {
+    if (!this.token) {
+      throw new Error("SessionToken not loaded \u2014 call load() first");
+    }
+    return this.token;
+  }
+  /**
+   * Constant-time compare against the bearer string the client sent. Returns
+   * `true` when the lengths match AND every byte is equal. Plain `===` would
+   * leak length information through timing.
+   */
+  matches(received) {
+    if (!this.token || !received) return false;
+    if (received.length !== this.token.length) return false;
+    let diff = 0;
+    for (let i = 0; i < received.length; i++) {
+      diff |= received.charCodeAt(i) ^ this.token.charCodeAt(i);
+    }
+    return diff === 0;
+  }
+};
+function parseBearer(header) {
+  if (!header) return null;
+  const m = /^Bearer\s+(.+)$/i.exec(header);
+  return m ? m[1].trim() : null;
+}
+
+// src/http/server.ts
+import * as http from "http";
+function createServer2(options) {
+  const ctx = {
+    options,
+    recentApplies: options.recentApplies ?? new RecentApplies(),
+    currentSelection: options.currentSelection ?? new CurrentSelection(),
+    sessionToken: options.sessionToken ?? new SessionToken()
+  };
+  return http.createServer((req, res) => {
+    void handle(req, res, ctx).catch((err) => {
+      writeJson(res, 500, {
+        ok: false,
+        reason: "internal-error",
+        details: err.message
+      });
+    });
+  });
+}
+async function handle(req, res, ctx) {
+  const origin = req.headers.origin;
+  const allowed = ctx.options.allowedOrigins ?? [];
+  const originAllowed = allowed.length === 0 || origin && allowed.includes(origin);
+  if (allowed.length === 0) {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+  } else if (originAllowed && origin) {
+    res.setHeader("Access-Control-Allow-Origin", origin);
+    res.setHeader("Vary", "Origin");
+  }
+  res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
+  res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+  if (req.method === "OPTIONS") {
+    res.writeHead(204);
+    res.end();
+    return;
+  }
+  const url = req.url ?? "/";
+  if (req.method === "GET" && url === "/health") {
+    writeJson(res, 200, { ok: true });
+    return;
+  }
+  if (!originAllowed) {
+    writeJson(res, 403, {
+      ok: false,
+      reason: "origin-not-allowed",
+      details: `Origin ${origin ?? "(missing)"} is not in the allowlist`
+    });
+    return;
+  }
+  if (req.method === "GET" && url === "/token") {
+    writeJson(res, 200, { token: ctx.sessionToken.get() });
+    return;
+  }
+  const bearer = parseBearer(req.headers.authorization);
+  if (!ctx.sessionToken.matches(bearer)) {
+    writeJson(res, 401, {
+      ok: false,
+      reason: "unauthorized",
+      details: "Include `Authorization: Bearer <token>` (fetch the token from GET /token)."
+    });
+    return;
+  }
+  if (req.method === "GET" && url === "/recent") {
+    writeJson(res, 200, { ok: true, applies: ctx.recentApplies.list() });
+    return;
+  }
+  if (req.method === "GET" && url === "/assets") {
+    await dispatchAssets(res, ctx);
+    return;
+  }
+  if (req.method === "POST" && url === "/apply") {
+    await dispatchMutation(req, res, ctx, false);
+    return;
+  }
+  if (req.method === "POST" && url === "/propose") {
+    await dispatchMutation(req, res, ctx, true);
+    return;
+  }
+  if (req.method === "POST" && url === "/revert") {
+    await dispatchRevert(req, res, ctx);
+    return;
+  }
+  if (req.method === "POST" && url === "/apply-css-prop") {
+    await dispatchCssProperty(req, res, ctx);
+    return;
+  }
+  if (req.method === "POST" && url === "/apply-styled-prop") {
+    await dispatchStyledProperty(req, res, ctx);
+    return;
+  }
+  if (req.method === "GET" && url === "/selection") {
+    writeJson(res, 200, {
+      ok: true,
+      selection: ctx.currentSelection.get()
+    });
+    return;
+  }
+  if (req.method === "POST" && url === "/selection") {
+    await dispatchSelection(req, res, ctx);
+    return;
+  }
+  if (req.method === "DELETE" && url === "/selection") {
+    ctx.currentSelection.clear();
+    writeJson(res, 200, { ok: true });
+    return;
+  }
+  writeJson(res, 404, {
+    ok: false,
+    reason: "not-found",
+    details: `No route for ${req.method} ${url}`
+  });
+}
+async function dispatchMutation(req, res, ctx, dryRun) {
+  let body;
+  try {
+    body = await readJsonBody(req);
+  } catch (err) {
+    writeJson(res, 400, {
+      ok: false,
+      reason: "invalid-json",
+      details: err.message
+    });
+    return;
+  }
+  const outcome = await applyToFile(body, {
+    workspaceRoot: ctx.options.workspaceRoot,
+    dryRun
+  });
+  if (outcome.ok) {
+    if (!dryRun) {
+      const input = body;
+      const beforeForBuffer = outcome.previousValue ?? input.before ?? "";
+      ctx.recentApplies.push({
+        file: input.file,
+        line: input.line,
+        col: input.col,
+        before: beforeForBuffer,
+        after: input.after,
+        appliedAt: Date.now()
+      });
+    }
+    writeJson(res, 200, { ok: true, diff: outcome.diff });
+    return;
+  }
+  writeJson(res, outcome.status, {
+    ok: false,
+    reason: outcome.reason,
+    details: outcome.details
+  });
+}
+async function dispatchRevert(req, res, ctx) {
+  let body;
+  try {
+    body = await readJsonBody(req);
+  } catch (err) {
+    writeJson(res, 400, {
+      ok: false,
+      reason: "invalid-json",
+      details: err.message
+    });
+    return;
+  }
+  const outcome = await revertToFile(
+    body,
+    { workspaceRoot: ctx.options.workspaceRoot, dryRun: false },
+    ctx.recentApplies
+  );
+  if (outcome.ok) {
+    writeJson(res, 200, { ok: true, diff: outcome.diff });
+    return;
+  }
+  writeJson(res, outcome.status, {
+    ok: false,
+    reason: outcome.reason,
+    details: outcome.details
+  });
+}
+async function dispatchCssProperty(req, res, ctx) {
+  let body;
+  try {
+    body = await readJsonBody(req);
+  } catch (err) {
+    writeJson(res, 400, {
+      ok: false,
+      reason: "invalid-json",
+      details: err.message
+    });
+    return;
+  }
+  const outcome = await applyCssProperty(body, {
+    workspaceRoot: ctx.options.workspaceRoot,
+    dryRun: false
+  });
+  if (outcome.ok) {
+    writeJson(res, 200, {
+      ok: true,
+      diff: outcome.diff,
+      selector: outcome.selector,
+      previousValue: outcome.previousValue
+    });
+    return;
+  }
+  writeJson(res, outcome.status, {
+    ok: false,
+    reason: outcome.reason,
+    details: outcome.details
+  });
+}
+async function dispatchStyledProperty(req, res, ctx) {
+  let body;
+  try {
+    body = await readJsonBody(req);
+  } catch (err) {
+    writeJson(res, 400, {
+      ok: false,
+      reason: "invalid-json",
+      details: err.message
+    });
+    return;
+  }
+  const outcome = await applyStyledProperty(body, {
+    workspaceRoot: ctx.options.workspaceRoot,
+    dryRun: false
+  });
+  if (outcome.ok) {
+    writeJson(res, 200, {
+      ok: true,
+      diff: outcome.diff,
+      componentName: outcome.componentName,
+      previousValue: outcome.previousValue
+    });
+    return;
+  }
+  writeJson(res, outcome.status, {
+    ok: false,
+    reason: outcome.reason,
+    details: outcome.details
+  });
+}
+async function dispatchAssets(res, ctx) {
+  const fs6 = await import("fs/promises");
+  const path4 = await import("path");
+  const IMAGE_EXTS = /* @__PURE__ */ new Set([
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".svg",
+    ".webp",
+    ".avif"
+  ]);
+  const publicDir = path4.join(ctx.options.workspaceRoot, "public");
+  async function walk(dir, rel) {
+    let entries = [];
+    try {
+      entries = await fs6.readdir(dir, { withFileTypes: true });
+    } catch {
+      return [];
+    }
+    const out = [];
+    for (const e of entries) {
+      const child = path4.join(dir, e.name);
+      const childRel = rel ? `${rel}/${e.name}` : e.name;
+      if (e.isDirectory()) {
+        const sub = await walk(child, childRel);
+        out.push(...sub);
+      } else if (e.isFile() && IMAGE_EXTS.has(path4.extname(e.name).toLowerCase())) {
+        out.push(`/${childRel}`);
+      }
+    }
+    return out;
+  }
+  try {
+    const assets = await walk(publicDir, "");
+    assets.sort();
+    writeJson(res, 200, { ok: true, assets });
+  } catch (err) {
+    writeJson(res, 500, {
+      ok: false,
+      reason: "assets-list-failed",
+      details: err.message
+    });
+  }
+}
+async function dispatchSelection(req, res, ctx) {
+  let body;
+  try {
+    body = await readJsonBody(req);
+  } catch (err) {
+    writeJson(res, 400, {
+      ok: false,
+      reason: "invalid-json",
+      details: err.message
+    });
+    return;
+  }
+  if (!isValidSelection(body)) {
+    writeJson(res, 400, {
+      ok: false,
+      reason: "invalid-input",
+      details: "Body must be { file, line, col, oid, className, tagName, componentName?, instanceCount }"
+    });
+    return;
+  }
+  ctx.currentSelection.set(body);
+  writeJson(res, 200, { ok: true });
+}
+function isValidSelection(x) {
+  if (!x || typeof x !== "object") return false;
+  const o = x;
+  return typeof o.file === "string" && typeof o.line === "number" && typeof o.col === "number" && typeof o.oid === "string" && typeof o.className === "string" && typeof o.tagName === "string" && (o.componentName === null || typeof o.componentName === "string") && typeof o.instanceCount === "number";
+}
+async function readJsonBody(req) {
+  const chunks = [];
+  for await (const chunk of req) {
+    chunks.push(chunk);
+    if (chunks.reduce((n, c) => n + c.length, 0) > 1024 * 1024) {
+      throw new Error("Request body exceeds 1 MB");
+    }
+  }
+  const raw = Buffer.concat(chunks).toString("utf8");
+  if (raw.length === 0) return {};
+  return JSON.parse(raw);
+}
+function writeJson(res, status, payload) {
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(payload));
+}
+
+export {
+  applyToFile,
+  revertToFile,
+  applyCssProperty,
+  applyStyledProperty,
+  RecentApplies,
+  CurrentSelection,
+  SessionToken,
+  createServer2 as createServer
+};
+//# sourceMappingURL=chunk-QEI2RGE2.js.map