recma-static-refiner 0.9.0

package/dist/index.js

@@ -0,0 +1,1109 @@
+import { is, traverse } from 'estree-toolkit';
+import { valueToEstree } from 'estree-util-value-to-estree';
+
+// src/index.ts
+var JSX_FACTORY_EXPORTS = /* @__PURE__ */ new Set(["jsx", "jsxs", "jsxDEV"]);
+function normalizeJsxFactoryName(name) {
+  return name.startsWith("_") ? name.slice(1) : name;
+}
+function getCallArgumentPath(callPath, index) {
+  const node = callPath.node;
+  if (!node || !is.callExpression(node)) return null;
+  const argPaths = callPath.get("arguments");
+  if (!Array.isArray(argPaths)) return null;
+  return argPaths.at(index) ?? null;
+}
+function isJsxPropsArgumentExpressionPath(path) {
+  return !!path?.node && is.expression(path.node);
+}
+function getJsxRuntimeCallArgs(callPath) {
+  const node = callPath.node;
+  if (!node || !is.callExpression(node)) return null;
+  if (!is.identifier(node.callee)) return null;
+  const calleeName = normalizeJsxFactoryName(node.callee.name);
+  if (!JSX_FACTORY_EXPORTS.has(calleeName)) return null;
+  const componentPath = getCallArgumentPath(callPath, 0);
+  const propsPath = getCallArgumentPath(callPath, 1);
+  if (!componentPath) return null;
+  if (!isJsxPropsArgumentExpressionPath(propsPath)) return null;
+  return { componentPath, propsPath };
+}
+
+// src/rule-validator.ts
+function validateRule(rule, componentName) {
+  if (!rule || typeof rule !== "object") {
+    throw new Error(
+      `[ValidationPlugin] Invalid rule for "${componentName}": Expected a rule object, got ${typeof rule}.`
+    );
+  }
+  const isEffective = rule.schema != null || rule.derive != null || rule.pruneKeys != null;
+  if (!isEffective) {
+    throw new Error(
+      `[ValidationPlugin] Invalid rule for "${componentName}": The rule is empty. It must define at least one of: 'schema', 'derive', or 'pruneKeys'.`
+    );
+  }
+  return rule;
+}
+
+// src/jsx-callsite-resolver.ts
+function extractComponentName(node) {
+  if (!node) return null;
+  if (is.identifier(node)) {
+    return node.name;
+  }
+  if (is.literal(node) && typeof node.value === "string") {
+    return node.value;
+  }
+  return null;
+}
+function createComponentResolver(rules) {
+  const registeredComponentNames = new Set(Object.keys(rules));
+  return (path) => {
+    const args = getJsxRuntimeCallArgs(path);
+    if (!args) return null;
+    const componentName = extractComponentName(args.componentPath.node);
+    if (!componentName) return null;
+    if (!registeredComponentNames.has(componentName)) return null;
+    const ruleEntry = rules[componentName];
+    if (!ruleEntry) return null;
+    const componentRule = validateRule(ruleEntry, componentName);
+    return {
+      componentName,
+      componentRule,
+      propsExpressionPath: args.propsPath
+    };
+  };
+}
+
+// src/validator.ts
+function validateWithSchema(schema, inputProps, componentName) {
+  if (!schema) {
+    return inputProps;
+  }
+  if (!("~standard" in schema)) {
+    throw new Error(
+      `The schema for "${componentName}" is invalid. Expected an object with the "~standard" property (e.g. Zod, Valibot), but received a plain object.`
+    );
+  }
+  const result = schema["~standard"].validate(inputProps);
+  if (result instanceof Promise) {
+    throw new Error(
+      `Async schema validation is not supported for "${componentName}".`
+    );
+  }
+  const [firstIssue] = result.issues ?? [];
+  if (firstIssue) {
+    const issuePath = firstIssue.path?.join(".") ?? "unknown";
+    throw new Error(
+      `Invalid props for "${componentName}" at "${issuePath}": ${firstIssue.message}`
+    );
+  }
+  if ("value" in result) {
+    return result.value;
+  }
+  return inputProps;
+}
+
+// src/differ/utils.ts
+var Tag = {
+  String: "[object String]",
+  Number: "[object Number]",
+  Boolean: "[object Boolean]",
+  BigInt: "[object BigInt]",
+  Date: "[object Date]",
+  RegExp: "[object RegExp]"
+};
+var RICH_TYPES = /* @__PURE__ */ new Set([
+  // Boxed Primitives
+  Tag.String,
+  Tag.Number,
+  Tag.Boolean,
+  Tag.BigInt,
+  // Complex Types
+  Tag.Date,
+  Tag.RegExp
+]);
+function isRichType(value) {
+  return RICH_TYPES.has(Object.prototype.toString.call(value));
+}
+function unbox(wrapper) {
+  return wrapper.valueOf();
+}
+function areBoxedPrimitivesEqual(left, right) {
+  const leftTypeTag = Object.prototype.toString.call(left);
+  const rightTypeTag = Object.prototype.toString.call(right);
+  if (leftTypeTag !== rightTypeTag) return false;
+  switch (leftTypeTag) {
+    // Group 1: Rely on .valueOf() (via unbox)
+    case Tag.Number: {
+      const leftValue = unbox(left);
+      const rightValue = unbox(right);
+      if (Number.isNaN(leftValue)) {
+        return Number.isNaN(rightValue);
+      }
+      return leftValue === rightValue;
+    }
+    case Tag.String:
+      return unbox(left) === unbox(right);
+    case Tag.Boolean:
+      return unbox(left) === unbox(right);
+    case Tag.BigInt:
+      return unbox(left) === unbox(right);
+    case Tag.Date:
+      return unbox(left) === unbox(right);
+    // Group 2: Relies on .toString()
+    case Tag.RegExp:
+      return left.toString() === right.toString();
+    default:
+      return false;
+  }
+}
+function areArraysShallowEqual(left, right) {
+  if (left === right) return true;
+  if (left?.length !== right?.length) return false;
+  return left.every((val, index) => Object.is(val, right[index]));
+}
+function normalizeOptions(options) {
+  return {
+    trackCircularReferences: true,
+    arrays: "atomic",
+    arrayEquality: "reference",
+    keysToSkip: [],
+    ...options
+  };
+}
+function isContainer(value) {
+  return typeof value === "object" && value !== null;
+}
+function getSafeValue(container, key) {
+  if (Array.isArray(container)) {
+    return container[Number(key)];
+  }
+  return container[key];
+}
+function shouldSkipKey(key, isContainerArray, keysToSkip) {
+  if (isContainerArray) return false;
+  if (!keysToSkip) return false;
+  return keysToSkip.includes(key);
+}
+function formatPathKey(key, isContainerArray) {
+  return isContainerArray ? Number(key) : key;
+}
+function prependPath(differences, pathSegment) {
+  for (const difference of differences) {
+    difference.path.unshift(pathSegment);
+  }
+  return differences;
+}
+function createChange(path, value, oldValue) {
+  return { type: "CHANGE", path, value, oldValue };
+}
+function createCreate(path, value) {
+  return { type: "CREATE", path, value };
+}
+function createRemove(path, oldValue) {
+  return { type: "REMOVE", path, oldValue };
+}
+
+// src/differ/strategies.ts
+function getArrayStrategy(options) {
+  switch (options.arrays) {
+    case "diff":
+      return { mode: "diff" };
+    case "ignore":
+      return { mode: "ignore" };
+    case "atomic": {
+      const comparator = options.arrayEquality === "reference" ? (a, b) => a === b : (a, b) => areArraysShallowEqual(a, b);
+      return { mode: "atomic", comparator };
+    }
+    default:
+      throw new Error(`Invalid array policy: ${options.arrays}`);
+  }
+}
+function checkArrayStrategy(strategy, previous, current) {
+  switch (strategy.mode) {
+    case "ignore":
+      return { shouldRecurse: false, diffs: [] };
+    case "atomic":
+      return strategy.comparator(previous, current) ? { shouldRecurse: false, diffs: [] } : {
+        shouldRecurse: false,
+        diffs: [createChange([], current, previous)]
+      };
+    case "diff":
+      return { shouldRecurse: true, diffs: [] };
+  }
+}
+
+// src/differ/index.ts
+function isCycleDetected(stack, previous, current) {
+  for (const [seenPrevious, seenCurrent] of stack) {
+    if (seenPrevious === previous && seenCurrent === current) return true;
+  }
+  return false;
+}
+function pushCycleEntry(options, stack, previous, current) {
+  if (!options.trackCircularReferences) return stack;
+  const newEntry = [previous, current];
+  return stack.concat([newEntry]);
+}
+function compareChildren(previousContainer, currentContainer, options, cycleStack, arrayStrategy) {
+  const differences = [];
+  const isPreviousArray = Array.isArray(previousContainer);
+  const isCurrentArray = Array.isArray(currentContainer);
+  const previousKeys = Object.keys(previousContainer);
+  for (const key of previousKeys) {
+    if (shouldSkipKey(key, isPreviousArray, options.keysToSkip)) continue;
+    const previousValue = getSafeValue(previousContainer, key);
+    const pathSegment = formatPathKey(key, isPreviousArray);
+    if (!(key in currentContainer)) {
+      differences.push(createRemove([pathSegment], previousValue));
+      continue;
+    }
+    const currentValue = getSafeValue(currentContainer, key);
+    if (isContainer(previousValue) && isContainer(currentValue) && Array.isArray(previousValue) === Array.isArray(currentValue)) {
+      if (options.trackCircularReferences && isCycleDetected(cycleStack, previousValue, currentValue)) {
+        continue;
+      }
+      if (!isRichType(previousValue)) {
+        const nextStack = pushCycleEntry(
+          options,
+          cycleStack,
+          previousValue,
+          currentValue
+        );
+        const childDiffs = compare(
+          previousValue,
+          currentValue,
+          options,
+          nextStack,
+          arrayStrategy
+        );
+        differences.push(...prependPath(childDiffs, pathSegment));
+        continue;
+      }
+    }
+    const hasValueMismatch = !Object.is(previousValue, currentValue);
+    const areBoxedPrimitives = isContainer(previousValue) && isContainer(currentValue) && areBoxedPrimitivesEqual(previousValue, currentValue);
+    if (hasValueMismatch && !areBoxedPrimitives) {
+      differences.push(
+        createChange([pathSegment], currentValue, previousValue)
+      );
+    }
+  }
+  const currentKeys = Object.keys(currentContainer);
+  for (const key of currentKeys) {
+    if (shouldSkipKey(key, isCurrentArray, options.keysToSkip)) continue;
+    if (!(key in previousContainer)) {
+      const currentValue = getSafeValue(currentContainer, key);
+      differences.push(
+        createCreate([formatPathKey(key, isCurrentArray)], currentValue)
+      );
+    }
+  }
+  return differences;
+}
+function compare(previous, current, options, cycleStack, arrayStrategy) {
+  if (Array.isArray(previous) && Array.isArray(current)) {
+    const { shouldRecurse, diffs } = checkArrayStrategy(
+      arrayStrategy,
+      previous,
+      current
+    );
+    if (!shouldRecurse) return diffs;
+  }
+  return compareChildren(previous, current, options, cycleStack, arrayStrategy);
+}
+function diff(previous, current, options = {}) {
+  const normalized = normalizeOptions(options);
+  const strategy = getArrayStrategy(normalized);
+  return compare(previous, current, normalized, [], strategy);
+}
+function isPatchablePropsRoot(node) {
+  return !!node && is.objectExpression(node);
+}
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === null || proto === Object.prototype;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isPropertyPath(value) {
+  return Array.isArray(value) && value.every((seg) => typeof seg === "string" || typeof seg === "number");
+}
+
+// src/utils/path-utils.ts
+function isKeyPreserved(key, preservedKeys) {
+  const lookupKey = String(key);
+  return preservedKeys.has(lookupKey);
+}
+
+// src/object-overlay.ts
+function overlayObject(base, overlay, preservedKeys) {
+  let resultObject;
+  for (const candidateKey of Object.keys(overlay)) {
+    if (isKeyPreserved(candidateKey, preservedKeys)) continue;
+    if (!Object.hasOwn(base, candidateKey)) continue;
+    const basePropValue = base[candidateKey];
+    const overlayPropValue = overlay[candidateKey];
+    const mergedValue = overlayValue(
+      basePropValue,
+      overlayPropValue,
+      preservedKeys
+    );
+    if (Object.is(mergedValue, basePropValue)) continue;
+    if (!resultObject) resultObject = { ...base };
+    resultObject[candidateKey] = mergedValue;
+  }
+  return resultObject ?? base;
+}
+function overlayValue(basePropValue, overlayPropValue, preservedKeys) {
+  if (Object.is(basePropValue, overlayPropValue)) return basePropValue;
+  if (Array.isArray(basePropValue) && Array.isArray(overlayPropValue)) {
+    return overlayPropValue;
+  }
+  if (isPlainObject(basePropValue) && isPlainObject(overlayPropValue)) {
+    return overlayObject(basePropValue, overlayPropValue, preservedKeys);
+  }
+  return overlayPropValue;
+}
+function applyOverlay(base, overlay, preservedKeys) {
+  if (Object.is(base, overlay)) return base;
+  return overlayObject(base, overlay, preservedKeys);
+}
+
+// src/patch-planner.ts
+function calculatePatches(extractedProps, validatedProps, preservedKeys) {
+  if (!isPlainObject(extractedProps) || !isPlainObject(validatedProps)) {
+    return [];
+  }
+  const diffTarget = applyOverlay(
+    extractedProps,
+    validatedProps,
+    preservedKeys
+  );
+  const difference = diff(extractedProps, diffTarget);
+  const patches = [];
+  for (const entry of difference) {
+    if (entry.type === "CHANGE") {
+      patches.push({
+        operation: "set",
+        path: entry.path,
+        value: entry.value
+      });
+      continue;
+    }
+    if (entry.type === "CREATE") {
+      continue;
+    }
+    if (entry.type === "REMOVE") {
+      continue;
+    }
+  }
+  return patches;
+}
+
+// src/extractor/constants.ts
+var UNRESOLVED = { success: false };
+function resolved(value) {
+  return { success: true, value };
+}
+var SKIP_VALUE = /* @__PURE__ */ Symbol.for("recma.extraction.skip");
+
+// src/extractor/static-resolver.ts
+function tryResolveLiteral(node) {
+  if (is.literal(node)) {
+    switch (typeof node.value) {
+      case "string":
+      case "number":
+      case "boolean":
+      case "bigint":
+        return resolved(node.value);
+      case "object":
+        if (node.value === null) {
+          return resolved(null);
+        }
+        if (node.value instanceof RegExp) {
+          return resolved(node.value);
+        }
+        break;
+    }
+  }
+  return UNRESOLVED;
+}
+function tryResolveIdentifier(node) {
+  if (is.identifier(node)) {
+    switch (node.name) {
+      case "undefined":
+        return resolved(void 0);
+      case "NaN":
+        return resolved(NaN);
+      case "Infinity":
+        return resolved(Infinity);
+    }
+  }
+  return UNRESOLVED;
+}
+function tryResolveTemplate(node) {
+  if (is.templateLiteral(node)) {
+    const parts = [];
+    for (const [index, quasi] of node.quasis.entries()) {
+      const text = quasi.value.cooked;
+      if (typeof text !== "string") return UNRESOLVED;
+      parts.push(text);
+      if (index < node.expressions.length) {
+        const exprResult = tryResolveStaticValue(node.expressions[index]);
+        if (!exprResult.success) return UNRESOLVED;
+        parts.push(`${exprResult.value}`);
+      }
+    }
+    return resolved(parts.join(""));
+  }
+  return UNRESOLVED;
+}
+function tryResolveStaticValue(node) {
+  let result;
+  if ((result = tryResolveLiteral(node)).success) return result;
+  if ((result = tryResolveIdentifier(node)).success) return result;
+  if ((result = tryResolveTemplate(node)).success) return result;
+  return UNRESOLVED;
+}
+
+// src/extractor/key-extractor.ts
+function tryExtractNamedKey(property) {
+  if (!property.computed && is.identifier(property.key)) {
+    return property.key.name;
+  }
+  return null;
+}
+function extractPropertyKey(property) {
+  const namedKey = tryExtractNamedKey(property);
+  if (namedKey !== null) {
+    return namedKey;
+  }
+  const resolution = tryResolveStaticValue(property.key);
+  if (resolution.success) {
+    const resolvedValue = resolution.value;
+    if (typeof resolvedValue === "string" || typeof resolvedValue === "number") {
+      return resolvedValue;
+    }
+  }
+  return null;
+}
+
+// src/expression-ref.ts
+var EXPRESSION_REF_KIND = /* @__PURE__ */ Symbol.for("recma.preservation.expression_ref");
+function createExpressionRef(path) {
+  return { __kind: EXPRESSION_REF_KIND, path };
+}
+function isExpressionRef(value) {
+  if (!isRecord(value)) return false;
+  if (value.__kind !== EXPRESSION_REF_KIND) return false;
+  return isPropertyPath(value.path);
+}
+
+// src/utils/array-utils.ts
+function preserveArrayElision(result, slotIndex) {
+  if (result.length < slotIndex + 1) result.length = slotIndex + 1;
+}
+function isArrayElision(array, slotIndex) {
+  return !(slotIndex in array);
+}
+
+// src/utils/type-guards.ts
+function is6(type) {
+  return (value) => typeof value === type;
+}
+var isNumber = is6("number");
+function isNaNValue(value) {
+  return isNumber(value) && Number.isNaN(value);
+}
+function isInfinityValue(value) {
+  return isNumber(value) && value === Infinity;
+}
+
+// src/utils/property-path-key.ts
+function composeSegmentCanonicalizers(canonicalizers) {
+  return function canonicalizeComposed(segment) {
+    let currentSegment = segment;
+    for (const canonicalize of canonicalizers) {
+      currentSegment = canonicalize(currentSegment);
+    }
+    return currentSegment;
+  };
+}
+function canonicalizeIdentifierNumberConstants(segment) {
+  if (!isNumber(segment)) return segment;
+  if (isNaNValue(segment)) return "NaN";
+  if (isInfinityValue(segment)) return "Infinity";
+  return segment;
+}
+function canonicalizeTemplateResults(segment) {
+  return segment;
+}
+var propertyPathSegmentCanonicalizer = composeSegmentCanonicalizers([
+  canonicalizeIdentifierNumberConstants,
+  canonicalizeTemplateResults
+  // canonicalizeUnaryNumberResults,
+  // canonicalizeArithmeticNumberResults
+]);
+function canonicalizePropertyPath(path) {
+  return path.map((segment) => propertyPathSegmentCanonicalizer(segment));
+}
+function stringifyPropertyPath(path) {
+  return JSON.stringify(canonicalizePropertyPath(path));
+}
+
+// src/patcher-object.ts
+function getFirstUnappliedPathKey(setPatchByPathKey, deletePathKeys) {
+  const firstSetKeyIterator = setPatchByPathKey.keys().next();
+  if (!firstSetKeyIterator.done) return firstSetKeyIterator.value;
+  const firstDeleteKeyIterator = deletePathKeys.values().next();
+  if (!firstDeleteKeyIterator.done) return firstDeleteKeyIterator.value;
+  return void 0;
+}
+function buildEstreeValue(value, expressionRefResolver) {
+  if (isExpressionRef(value)) {
+    const resolvedExpression = expressionRefResolver(value);
+    if (!resolvedExpression) {
+      throw new Error(
+        `[recma] Cannot inline ExpressionRef at path "${value.path.join(".")}".`
+      );
+    }
+    return resolvedExpression;
+  }
+  if (Array.isArray(value)) {
+    const elements = new Array(value.length);
+    for (let slotIndex = 0; slotIndex < value.length; slotIndex++) {
+      if (isArrayElision(value, slotIndex)) {
+        elements[slotIndex] = null;
+        continue;
+      }
+      elements[slotIndex] = buildEstreeValue(
+        value[slotIndex],
+        expressionRefResolver
+      );
+    }
+    return {
+      type: "ArrayExpression",
+      elements
+    };
+  }
+  if (isPlainObject(value)) {
+    const properties = [];
+    for (const [key, child] of Object.entries(value)) {
+      properties.push({
+        type: "Property",
+        /**
+         * Static object key (no brackets):
+         * - `{ foo: 1 }`        ✅
+         * - `{ [foo]: 1 }`      ❌
+         */
+        computed: false,
+        /**
+         * Always emit explicit key/value pairs:
+         * - `{ foo: foo }`      ✅
+         * - `{ foo }`           ❌ (shorthand)
+         */
+        shorthand: false,
+        /**
+         * Not method syntax:
+         * - `{ foo: () => {} }` ✅ (value is an expression)
+         * - `{ foo() {} }`      ❌ (method)
+         */
+        method: false,
+        /**
+         * Regular initializer property:
+         * - `{ foo: value }`    ✅
+         * - `{ get foo() {} }`  ❌
+         * - `{ set foo(v) {} }` ❌
+         */
+        kind: "init",
+        /**
+         * Use a string-literal key so any JS object key is representable
+         * (including keys that are not valid identifiers, e.g. `"data-id"`, `"1"`, `"a b"`).
+         */
+        key: { type: "Literal", value: key },
+        /**
+         * Encode the value as an ESTree expression.
+         * "Recursive" means nested arrays/objects are encoded by calling `buildEstreeValue`
+         * again for their children until primitives/ExpressionRefs are reached.
+         */
+        value: buildEstreeValue(child, expressionRefResolver)
+      });
+    }
+    return {
+      type: "ObjectExpression",
+      properties
+    };
+  }
+  return valueToEstree(value);
+}
+function tryAppendObjectKeySegment(cursor, pathSegments) {
+  const parentNode = cursor.parentPath?.node;
+  if (!parentNode) return void 0;
+  if (is.property(cursor.node) && is.objectExpression(parentNode)) {
+    const keySegment = extractPropertyKey(cursor.node);
+    if (keySegment === null) return null;
+    pathSegments.push(keySegment);
+    return cursor.parentPath;
+  }
+  return void 0;
+}
+function getRelativePathFromRoot(targetPath) {
+  const pathSegments = [];
+  let cursor = targetPath;
+  while (cursor?.parentPath) {
+    const parentNode = cursor.parentPath.node;
+    const node = cursor.node;
+    if (!parentNode || !node) break;
+    if (is.property(parentNode) && cursor.key === "value") {
+      cursor = cursor.parentPath;
+      continue;
+    }
+    const nextFromObject = tryAppendObjectKeySegment(cursor, pathSegments);
+    if (nextFromObject === null) return null;
+    if (nextFromObject) {
+      cursor = nextFromObject;
+      continue;
+    }
+    cursor = cursor.parentPath;
+  }
+  return pathSegments.reverse();
+}
+function buildPatchIndex(patches) {
+  const setPatchByPathKey = /* @__PURE__ */ new Map();
+  const deletePathKeys = /* @__PURE__ */ new Set();
+  for (const patch of patches) {
+    const pathKey = stringifyPropertyPath(patch.path);
+    if (patch.operation === "set") {
+      setPatchByPathKey.set(pathKey, patch);
+    } else {
+      deletePathKeys.add(pathKey);
+    }
+  }
+  return { setPatchByPathKey, deletePathKeys };
+}
+function applyObjectPropertyPatchesIfNeeded(path, state) {
+  if (!path.node) return;
+  const propertyKey = extractPropertyKey(path.node);
+  if (propertyKey === null) return;
+  if (isKeyPreserved(propertyKey, state.preservedKeys)) {
+    path.skipChildren();
+    return;
+  }
+  const propPath = getRelativePathFromRoot(path);
+  if (!propPath) return;
+  const pathKey = stringifyPropertyPath(propPath);
+  if (state.deletePathKeys.has(pathKey)) {
+    path.remove();
+    state.deletePathKeys.delete(pathKey);
+    return;
+  }
+  const patch = state.setPatchByPathKey.get(pathKey);
+  if (!patch) return;
+  path.get("value").replaceWith(buildEstreeValue(patch.value, state.expressionRefResolver));
+  state.setPatchByPathKey.delete(pathKey);
+}
+function finalizeApplyPatchesResult(setPatchByPathKey, deletePathKeys) {
+  const remainingSetPathKeys = Array.from(setPatchByPathKey.keys());
+  const remainingDeletePathKeys = Array.from(deletePathKeys.values());
+  const firstUnappliedPathKey = getFirstUnappliedPathKey(
+    setPatchByPathKey,
+    deletePathKeys
+  );
+  return {
+    firstUnappliedPathKey,
+    remainingSetPathKeys,
+    remainingDeletePathKeys,
+    remainingSetCount: remainingSetPathKeys.length,
+    remainingDeleteCount: remainingDeletePathKeys.length
+  };
+}
+function createPatchApplicationVisitors() {
+  return {
+    Property(path, state) {
+      applyObjectPropertyPatchesIfNeeded(path, state);
+    }
+    // ArrayExpression(path, state) {
+    //   applyArrayElementPatchesIfNeeded(path, state);
+    // }
+  };
+}
+function applyPatchesToEstree(propsRootPath, patches, preservedKeys, options) {
+  const { setPatchByPathKey, deletePathKeys } = buildPatchIndex(patches);
+  if (!isPatchablePropsRoot(propsRootPath.node)) {
+    return finalizeApplyPatchesResult(setPatchByPathKey, deletePathKeys);
+  }
+  const state = {
+    preservedKeys,
+    setPatchByPathKey,
+    deletePathKeys,
+    expressionRefResolver: options.expressionRefResolver
+  };
+  const visitors = createPatchApplicationVisitors();
+  traverse(propsRootPath.node, visitors, state);
+  return finalizeApplyPatchesResult(setPatchByPathKey, deletePathKeys);
+}
+
+// src/consolidatePatches.ts
+function consolidatePatches(groups) {
+  const patchByPathKey = /* @__PURE__ */ new Map();
+  const phaseByPathKey = /* @__PURE__ */ new Map();
+  for (const { phase, patches } of groups) {
+    for (const patch of patches) {
+      const pathKey = stringifyPropertyPath(patch.path);
+      patchByPathKey.set(pathKey, patch);
+      phaseByPathKey.set(pathKey, phase);
+    }
+  }
+  return {
+    patches: Array.from(patchByPathKey.values()),
+    phaseByPathKey
+  };
+}
+
+// src/report.ts
+function formatPathKeyForDisplay(pathKey) {
+  try {
+    const parsed = JSON.parse(pathKey);
+    if (isPropertyPath(parsed) && parsed.length > 0) {
+      return parsed.join(".");
+    }
+  } catch {
+  }
+  return pathKey;
+}
+function formatPatchFailureSummary(context, getPhase) {
+  const setKeys = context.remainingSetPathKeys;
+  const deleteKeys = context.remainingDeletePathKeys;
+  if (setKeys.length === 0 && deleteKeys.length === 0) return void 0;
+  const parts = [];
+  const operationParts = [];
+  if (setKeys.length > 0) {
+    const setPhaseStats = formatPhaseDistribution(setKeys, getPhase);
+    operationParts.push(
+      `set=${setKeys.length}${setPhaseStats ? ` (${setPhaseStats})` : ""}`
+    );
+  }
+  if (deleteKeys.length > 0) {
+    const deletePhaseStats = formatPhaseDistribution(deleteKeys, getPhase);
+    operationParts.push(
+      `delete=${deleteKeys.length}${deletePhaseStats ? ` (${deletePhaseStats})` : ""}`
+    );
+  }
+  parts.push(`Summary: unapplied ${operationParts.join(", ")}`);
+  const allKeys = [...setKeys, ...deleteKeys];
+  const previewLimit = context.maxPreviewPaths != null ? context.maxPreviewPaths : 5;
+  if (previewLimit > 0) {
+    const previewStats = formatPathPreview(allKeys, previewLimit, getPhase);
+    if (previewStats) {
+      parts.push(previewStats);
+    }
+  }
+  return parts.join("; ");
+}
+function formatPhaseDistribution(pathKeys, getPhase) {
+  if (pathKeys.length === 0) return void 0;
+  const countByPhase = /* @__PURE__ */ new Map();
+  for (const key of pathKeys) {
+    const phase = getPhase(key) ?? "unknown";
+    const current = countByPhase.get(phase) ?? 0;
+    countByPhase.set(phase, current + 1);
+  }
+  return Array.from(countByPhase.entries()).map(([phase, count]) => `${phase}=${count}`).join(", ");
+}
+function formatPathPreview(pathKeys, limit, getPhase) {
+  if (pathKeys.length === 0 || limit <= 0) return void 0;
+  const items = pathKeys.slice(0, limit).map((key) => {
+    const phase = getPhase(key) ?? "unknown";
+    return `"${formatPathKeyForDisplay(key)}" (${phase})`;
+  });
+  if (pathKeys.length > limit) {
+    items.push(`\u2026 (${pathKeys.length - limit} more)`);
+  }
+  return `preview: ${items.join(", ")}`;
+}
+function formatPatchFailureHint(phase) {
+  switch (phase) {
+    case "derive":
+      return "Hint: derive patches are leaf-only. Ensure the prop exists in MDX (e.g. <CustomComponent test={...} />) before setting it.";
+    // covers diff, prune, and undefined
+    default:
+      return void 0;
+  }
+}
+function reportPatchFailure(firstUnappliedPathKey, options) {
+  const phase = options.getPatchPhaseByPathKey(firstUnappliedPathKey);
+  const propPath = formatPathKeyForDisplay(firstUnappliedPathKey);
+  const hint = formatPatchFailureHint(phase);
+  const phaseAnnotation = phase ? ` (phase: ${phase})` : "";
+  const summaryLine = formatPatchFailureSummary(
+    options.summaryContext,
+    options.getPatchPhaseByPathKey
+  );
+  const messageParts = [
+    `[recma] Cannot fully apply patches for ${options.componentName}.`,
+    `First un-applied path: "${propPath}"${phaseAnnotation} (non-literal AST shape or missing path)`
+  ];
+  if (hint) messageParts.push(hint);
+  if (summaryLine) messageParts.push(summaryLine);
+  const message = messageParts.join("\n");
+  throw new Error(message);
+}
+
+// src/prune-patches.ts
+function planPrunePatches(existingProps, pruneKeys, preservedKeys) {
+  if (!pruneKeys || pruneKeys.length === 0) return [];
+  if (!isPlainObject(existingProps)) return [];
+  const patches = [];
+  const uniquePruneKeys = new Set(pruneKeys);
+  for (const key of uniquePruneKeys) {
+    if (preservedKeys.has(key)) continue;
+    if (Object.hasOwn(existingProps, key)) {
+      patches.push({ operation: "delete", path: [key] });
+    }
+  }
+  return patches;
+}
+function formatPath(base, segment) {
+  return typeof segment === "number" ? `${base}[${segment}]` : `${base}.${segment}`;
+}
+function integrateArrayElement(target, value) {
+  if (value === SKIP_VALUE) {
+    return SKIP_VALUE;
+  }
+  target.push(value);
+}
+function integrateObjectEntry(target, key, value) {
+  if (value !== SKIP_VALUE) {
+    target[key] = value;
+  }
+}
+function extractStaticValueFromArrayExpression(expressionNode, options, pathLabel, pathSegments) {
+  const candidate = [];
+  for (const [index, elementNode] of expressionNode.elements.entries()) {
+    if (elementNode === null) {
+      preserveArrayElision(candidate, index);
+      continue;
+    }
+    if (is.spreadElement(elementNode)) {
+      return SKIP_VALUE;
+    }
+    const elementLabel = formatPath(pathLabel, index);
+    const elementPath = [...pathSegments, index];
+    const extracted = extractStaticValueFromExpression(
+      elementNode,
+      options,
+      elementLabel,
+      elementPath
+    );
+    const integrationStatus = integrateArrayElement(candidate, extracted);
+    if (integrationStatus === SKIP_VALUE) {
+      return SKIP_VALUE;
+    }
+  }
+  return candidate;
+}
+function extractStaticValueFromObjectExpression(expressionNode, options, pathLabel, pathSegments) {
+  const aggregate = {};
+  for (const propertyNode of expressionNode.properties) {
+    if (is.spreadElement(propertyNode)) {
+      continue;
+    }
+    const key = extractPropertyKey(propertyNode);
+    if (key === null) {
+      continue;
+    }
+    const valueLabel = formatPath(pathLabel, key);
+    const valuePath = [...pathSegments, key];
+    if (isKeyPreserved(key, options.preservedKeys)) {
+      if (is.expression(propertyNode.value)) {
+        options.onPreservedExpression?.({
+          path: valuePath,
+          expression: propertyNode.value
+        });
+      }
+      aggregate[key] = createExpressionRef(valuePath);
+      continue;
+    }
+    const extracted = extractStaticValueFromExpression(
+      propertyNode.value,
+      options,
+      valueLabel,
+      valuePath
+    );
+    integrateObjectEntry(aggregate, key, extracted);
+  }
+  return aggregate;
+}
+function extractStaticValueFromExpression(expressionNode, options, pathLabel, pathSegments = []) {
+  const staticResolution = tryResolveStaticValue(expressionNode);
+  if (staticResolution.success) {
+    return staticResolution.value;
+  }
+  if (is.arrayExpression(expressionNode)) {
+    return extractStaticValueFromArrayExpression(
+      expressionNode,
+      options,
+      pathLabel,
+      pathSegments
+    );
+  }
+  if (is.objectExpression(expressionNode)) {
+    return extractStaticValueFromObjectExpression(
+      expressionNode,
+      options,
+      pathLabel,
+      pathSegments
+    );
+  }
+  return SKIP_VALUE;
+}
+function extractStaticProps(propsNode, options, pathLabel) {
+  const extracted = extractStaticValueFromExpression(
+    propsNode,
+    options,
+    pathLabel
+  );
+  if (extracted === SKIP_VALUE) return null;
+  if (!isPlainObject(extracted)) return null;
+  return extracted;
+}
+
+// src/patch-guards.ts
+function findRestrictedKey(patch, restrictedKeys, scope) {
+  {
+    const [first] = patch.path;
+    return typeof first === "string" && restrictedKeys.has(first) ? first : null;
+  }
+}
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function assertPatchesRespectPreservation(patches, restrictedKeys, componentName, options) {
+  for (const patch of patches) {
+    const violatedKey = findRestrictedKey(patch, restrictedKeys);
+    if (!violatedKey) continue;
+    const pathDetail = "";
+    const capitalizedLabel = capitalize(options.keyTypeLabel);
+    throw new Error(
+      `[recma] Patch targets ${options.keyTypeLabel} key "${violatedKey}"${pathDetail} for ${componentName}. ${capitalizedLabel} keys must not be patched as they represent runtime-owned subtrees.`
+    );
+  }
+}
+
+// src/derive-patches.ts
+function collectDerivePatches(deriveFn, derivationInput) {
+  if (!deriveFn) return [];
+  const patches = [];
+  deriveFn(derivationInput, (values) => {
+    for (const [key, value] of Object.entries(values)) {
+      patches.push({ operation: "set", path: [key], value });
+    }
+  });
+  return patches;
+}
+
+// src/visitor.ts
+function processComponent(match, options, preservedKeys) {
+  const { componentName, componentRule, propsExpressionPath } = match;
+  const applyTransforms = options.applyTransforms ?? true;
+  const propsNode = propsExpressionPath.node;
+  if (!propsNode) return;
+  const preservedExpressionsByPath = /* @__PURE__ */ new Map();
+  const extractedProps = extractStaticProps(
+    propsNode,
+    {
+      preservedKeys,
+      onPreservedExpression: (info) => {
+        preservedExpressionsByPath.set(
+          stringifyPropertyPath(info.path),
+          info.expression
+        );
+      }
+    },
+    `${componentName}.props`
+  );
+  const derivationInput = validateWithSchema(
+    componentRule.schema,
+    extractedProps,
+    componentName
+  );
+  if (!applyTransforms) return;
+  const diffPatches = calculatePatches(
+    extractedProps,
+    derivationInput,
+    preservedKeys
+  );
+  const derivedPatches = collectDerivePatches(
+    componentRule.derive,
+    derivationInput
+  );
+  const prunePatches = planPrunePatches(
+    extractedProps,
+    componentRule.pruneKeys,
+    preservedKeys
+  );
+  const { patches, phaseByPathKey } = consolidatePatches([
+    { phase: "diff", patches: diffPatches },
+    { phase: "derive", patches: derivedPatches },
+    { phase: "prune", patches: prunePatches }
+  ]);
+  assertPatchesRespectPreservation(patches, preservedKeys, componentName, {
+    keyTypeLabel: "preserved"
+  });
+  if (patches.length === 0) return;
+  const applyResult = applyPatchesToEstree(
+    propsExpressionPath,
+    patches,
+    preservedKeys,
+    {
+      expressionRefResolver: (ref) => preservedExpressionsByPath.get(stringifyPropertyPath(ref.path)) ?? null
+    }
+  );
+  if (applyResult.firstUnappliedPathKey) {
+    reportPatchFailure(applyResult.firstUnappliedPathKey, {
+      componentName,
+      getPatchPhaseByPathKey: (pathKey) => phaseByPathKey.get(pathKey),
+      summaryContext: {
+        remainingSetPathKeys: applyResult.remainingSetPathKeys,
+        remainingDeletePathKeys: applyResult.remainingDeletePathKeys
+      }
+    });
+  }
+}
+function createScopedVisitor(resolveComponentMatch, options) {
+  const preservedKeys = new Set(options.preservedKeys ?? ["children"]);
+  return {
+    CallExpression(path) {
+      const match = resolveComponentMatch(path);
+      if (!match) return;
+      processComponent(match, options, preservedKeys);
+    }
+  };
+}
+
+// src/types/registry.ts
+function defineRuleRegistry(registry) {
+  return registry;
+}
+function defineRule() {
+  return (rule) => rule;
+}
+
+// src/index.ts
+var recmaStaticRefiner = (options) => {
+  const resolveComponentMatch = createComponentResolver(options.rules);
+  const visitor = createScopedVisitor(resolveComponentMatch, options);
+  const transformer = (tree) => {
+    if (!is.program(tree)) return;
+    traverse(tree, visitor);
+  };
+  return transformer;
+};
+
+export { defineRule, defineRuleRegistry, recmaStaticRefiner };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map