@acebuilder/component-tagger 0.0.1

package/index.d.ts

@@ -0,0 +1,15 @@
+import type { NextConfig } from 'next'
+
+export interface AceBuilderComponentTaggerOptions {
+  /** Test regex for files to process. If provided, takes precedence over `extensions`. */
+  test?: RegExp
+}
+
+export type WithAceBuilderComponentTagger = (config: NextConfig) => NextConfig
+
+/**
+ * Next.js plugin that injects the AceBuilder component tagger loader into the webpack pipeline.
+ */
+declare function withAceBuilderComponentTagger(options?: AceBuilderComponentTaggerOptions): WithAceBuilderComponentTagger
+
+export default withAceBuilderComponentTagger

package/index.js

@@ -0,0 +1,66 @@
+'use strict'
+
+/**
+ * Next.js plugin that injects the AceBuilder component tagger loader into the webpack pipeline.
+ *
+ * Purpose:
+ * - Automatically adds a pre-loader that parses JSX/TSX modules and injects data attributes
+ *   used by AceBuilder for component discovery and visualization.
+ *
+ * Options:
+ * - pluginOptions.test (RegExp): Which files to process. Defaults to `/\.((j|t)sx)$/i`.
+ *
+ * Usage (CommonJS in next.config.js / next.config.mjs):
+ *
+ *   const withComponentTagger = require('@acebuilder/component-tagger')({
+ *     // Optionally override which files to process
+ *     // test: /\.tsx?$/i,
+ *   })
+ *
+ *   module.exports = withComponentTagger({
+ *     reactStrictMode: true,
+ *     // ...any other Next.js config
+ *   })
+ *
+ * How it works:
+ * - Adds a webpack rule (enforce: 'pre') that applies to files matching `test`, excluding node_modules.
+ * - The rule uses the local loader at `./lib/loader`.
+ * - If the user already defines a `webpack` function in their Next config, we call it afterwards
+ *   to preserve user customizations.
+ */
+module.exports = (pluginOptions = {}) => (inputConfig = {}) => {
+  if (
+    process.env.ACEBUILDER_TAGGER_ENABLED === '0' ||
+    process.env.ACEBUILDER_TAGGER_ENABLED === 'false' ||
+    !process.env.ACEBUILDER_TAGGER_ENABLED
+  ) {
+    console.log('AceBuilder Component Tagger is disabled', process.env.ACEBUILDER_TAGGER_ENABLED)
+    return inputConfig
+  }
+  const test = pluginOptions.test || /\.((j|t)sx)$/i
+
+  /** @type {import('next').NextConfig} */
+  const nextConfig = {
+    ...inputConfig,
+    webpack(config, options) {
+      config.module.rules.push({
+        test,
+        exclude: /node_modules/,
+        enforce: 'pre',
+        use: {
+          loader: require.resolve('./lib/loader'),
+        },
+      })
+      if (typeof inputConfig.webpack === 'function') {
+        return inputConfig.webpack(config, options)
+      }
+
+      return config
+    },
+  }
+
+  return nextConfig
+}
+
+// Provide a .default for ESM interop so `import x from` works reliably
+module.exports.default = module.exports

package/lib/blacklists.js

@@ -0,0 +1,296 @@
+/*
+ * Blacklists for components that should not be tagged by the AceBuilder component tagger.
+ *
+ * These lists mirror the ones that were embedded in the app's loader.
+ * They are kept here so the loader can import them and so they can be extended/tested independently.
+ *
+ * Why blacklist?
+ * - Some libraries (e.g., react-three-fiber and @react-three/drei) expose many JSX elements that map to low-level 3D primitives.
+ *   Tagging those would create excessive noise and large HTML payloads with little benefit for UI inspection.
+ * - By excluding these known elements, we keep tagging focused on meaningful app-level components.
+ */
+'use strict'
+
+/**
+ * List of JSX element names originating from react-three-fiber that we intentionally skip tagging.
+ *
+ * Notes:
+ * - The names here match the JSX tag identifiers (lower/upper case as used in code) that the tagger detects at parse time.
+ * - If a new react-three-fiber element starts appearing in your app and shouldn't be tagged, add it here.
+ */
+const threeFiberElems = [
+  'object3D',
+  'audioListener',
+  'positionalAudio',
+  'mesh',
+  'batchedMesh',
+  'instancedMesh',
+  'scene',
+  'sprite',
+  'lOD',
+  'skinnedMesh',
+  'skeleton',
+  'bone',
+  'lineSegments',
+  'lineLoop',
+  'points',
+  'group',
+  'camera',
+  'perspectiveCamera',
+  'orthographicCamera',
+  'cubeCamera',
+  'arrayCamera',
+  'instancedBufferGeometry',
+  'bufferGeometry',
+  'boxBufferGeometry',
+  'circleBufferGeometry',
+  'coneBufferGeometry',
+  'cylinderBufferGeometry',
+  'dodecahedronBufferGeometry',
+  'extrudeBufferGeometry',
+  'icosahedronBufferGeometry',
+  'latheBufferGeometry',
+  'octahedronBufferGeometry',
+  'planeBufferGeometry',
+  'polyhedronBufferGeometry',
+  'ringBufferGeometry',
+  'shapeBufferGeometry',
+  'sphereBufferGeometry',
+  'tetrahedronBufferGeometry',
+  'torusBufferGeometry',
+  'torusKnotBufferGeometry',
+  'tubeBufferGeometry',
+  'wireframeGeometry',
+  'tetrahedronGeometry',
+  'octahedronGeometry',
+  'icosahedronGeometry',
+  'dodecahedronGeometry',
+  'polyhedronGeometry',
+  'tubeGeometry',
+  'torusKnotGeometry',
+  'torusGeometry',
+  'sphereGeometry',
+  'ringGeometry',
+  'planeGeometry',
+  'latheGeometry',
+  'shapeGeometry',
+  'extrudeGeometry',
+  'edgesGeometry',
+  'coneGeometry',
+  'cylinderGeometry',
+  'circleGeometry',
+  'boxGeometry',
+  'capsuleGeometry',
+  'material',
+  'shadowMaterial',
+  'spriteMaterial',
+  'rawShaderMaterial',
+  'shaderMaterial',
+  'pointsMaterial',
+  'meshPhysicalMaterial',
+  'meshStandardMaterial',
+  'meshPhongMaterial',
+  'meshToonMaterial',
+  'meshNormalMaterial',
+  'meshLambertMaterial',
+  'meshDepthMaterial',
+  'meshDistanceMaterial',
+  'meshBasicMaterial',
+  'meshMatcapMaterial',
+  'lineDashedMaterial',
+  'lineBasicMaterial',
+  'primitive',
+  'light',
+  'spotLightShadow',
+  'spotLight',
+  'pointLight',
+  'rectAreaLight',
+  'hemisphereLight',
+  'directionalLightShadow',
+  'directionalLight',
+  'ambientLight',
+  'lightShadow',
+  'ambientLightProbe',
+  'hemisphereLightProbe',
+  'lightProbe',
+  'spotLightHelper',
+  'skeletonHelper',
+  'pointLightHelper',
+  'hemisphereLightHelper',
+  'gridHelper',
+  'polarGridHelper',
+  'directionalLightHelper',
+  'cameraHelper',
+  'boxHelper',
+  'box3Helper',
+  'planeHelper',
+  'arrowHelper',
+  'axesHelper',
+  'texture',
+  'videoTexture',
+  'dataTexture',
+  'dataTexture3D',
+  'compressedTexture',
+  'cubeTexture',
+  'canvasTexture',
+  'depthTexture',
+  'raycaster',
+  'vector2',
+  'vector3',
+  'vector4',
+  'euler',
+  'matrix3',
+  'matrix4',
+  'quaternion',
+  'bufferAttribute',
+  'float16BufferAttribute',
+  'float32BufferAttribute',
+  'float64BufferAttribute',
+  'int8BufferAttribute',
+  'int16BufferAttribute',
+  'int32BufferAttribute',
+  'uint8BufferAttribute',
+  'uint16BufferAttribute',
+  'uint32BufferAttribute',
+  'instancedBufferAttribute',
+  'color',
+  'fog',
+  'fogExp2',
+  'shape',
+  'colorShiftMaterial',
+]
+
+/**
+ * List of JSX element names from @react-three/drei we do not tag.
+ *
+ * Drei provides many helpers and higher-level constructs around react-three-fiber.
+ * These are still generally low-level from a UI tagging perspective, so we exclude them by default.
+ */
+const dreiElems = [
+  'AsciiRenderer',
+  'Billboard',
+  'Clone',
+  'ComputedAttribute',
+  'Decal',
+  'Edges',
+  'Effects',
+  'GradientTexture',
+  'MarchingCubes',
+  'Outlines',
+  'PositionalAudio',
+  'Sampler',
+  'ScreenSizer',
+  'ScreenSpace',
+  'Splat',
+  'Svg',
+  'Text',
+  'Text3D',
+  'Trail',
+  'CubeCamera',
+  'OrthographicCamera',
+  'PerspectiveCamera',
+  'CameraControls',
+  'FaceControls',
+  'KeyboardControls',
+  'MotionPathControls',
+  'PresentationControls',
+  'ScrollControls',
+  'DragControls',
+  'GizmoHelper',
+  'Grid',
+  'Helper',
+  'PivotControls',
+  'TransformControls',
+  'CubeTexture',
+  'Fbx',
+  'Gltf',
+  'Ktx2',
+  'Loader',
+  'Progress',
+  'ScreenVideoTexture',
+  'Texture',
+  'TrailTexture',
+  'VideoTexture',
+  'WebcamVideoTexture',
+  'CycleRaycast',
+  'DetectGPU',
+  'Example',
+  'FaceLandmarker',
+  'Fbo',
+  'Html',
+  'Select',
+  'SpriteAnimator',
+  'StatsGl',
+  'Stats',
+  'Trail',
+  'Wireframe',
+  'CurveModifier',
+  'AdaptiveDpr',
+  'AdaptiveEvents',
+  'BakeShadows',
+  'Bvh',
+  'Detailed',
+  'Instances',
+  'Merged',
+  'meshBounds',
+  'PerformanceMonitor',
+  'Points',
+  'Preload',
+  'Segments',
+  'Fisheye',
+  'Hud',
+  'Mask',
+  'MeshPortalMaterial',
+  'RenderCubeTexture',
+  'RenderTexture',
+  'View',
+  'MeshDiscardMaterial',
+  'MeshDistortMaterial',
+  'MeshReflectorMaterial',
+  'MeshRefractionMaterial',
+  'MeshTransmissionMaterial',
+  'MeshWobbleMaterial',
+  'PointMaterial',
+  'shaderMaterial',
+  'SoftShadows',
+  'CatmullRomLine',
+  'CubicBezierLine',
+  'Facemesh',
+  'Line',
+  'Mesh',
+  'QuadraticBezierLine',
+  'RoundedBox',
+  'ScreenQuad',
+  'AccumulativeShadows',
+  'Backdrop',
+  'BBAnchor',
+  'Bounds',
+  'CameraShake',
+  'Caustics',
+  'Center',
+  'Cloud',
+  'ContactShadows',
+  'Environment',
+  'Float',
+  'Lightformer',
+  'MatcapTexture',
+  'NormalTexture',
+  'RandomizedLight',
+  'Resize',
+  'ShadowAlpha',
+  'Shadow',
+  'Sky',
+  'Sparkles',
+  'SpotLightShadow',
+  'SpotLight',
+  'Stage',
+  'Stars',
+  'OrbitControls',
+]
+
+/**
+ * Exports the blacklists for components that should not be tagged by the AceBuilder component tagger.
+ *
+ * @module blacklists
+ */
+module.exports = { threeFiberElems, dreiElems }

package/lib/loader.js

@@ -0,0 +1,167 @@
+'use strict'
+
+const { parse } = require('@babel/parser')
+const MagicString = require('magic-string')
+const { walk } = require('estree-walker')
+const path = require('path')
+const {
+  shouldTag,
+  isNextImageAlias,
+  findVariableDeclarations,
+  findMapContext,
+  getSemanticName,
+} = require('./utils')
+
+/**
+ * AceBuilder Component Tagger Loader
+ *
+ * This webpack-style loader parses source files and injects data attributes
+ * onto JSX elements so the AceBuilder app can locate, highlight, and map
+ * UI components in the rendered DOM.
+ *
+ * Key behaviors:
+ * - Skips files under `node_modules`.
+ * - Parses with Babel (JSX + TypeScript) and traverses the AST.
+ * - Injects `data-acebuilder-id` and `data-acebuilder-name` onto selected JSX elements.
+ * - Adds `data-map-index={index}` when inside an Array.map callback with an index parameter.
+ * - Respects blacklists for react-three-fiber / @react-three/drei via `shouldTag`.
+ * - Treats aliases of `next/image` as semantic `img` for tagging purposes.
+ * - Normalizes and preserves source maps for compatibility with webpack/Turbopack.
+ *
+ * The `data-acebuilder-id` contains a stable reference in the format:
+ *   "<relativeFilePath>:<line>:<column>[@<context>...@<refName>]"
+ * Where optional context can include the mapped array name and referenced variable names.
+ *
+ * @this {import('webpack').LoaderContext<unknown>}
+ * @param {string} code - The module source code.
+ * @param {any} map - An optional incoming sourcemap (object or stringified JSON).
+ * @returns {void} - Uses the async callback to return results to webpack.
+ */
+function componentTagger(code, map) {
+
+  const done = this.async()
+  try {
+    // Normalize incoming sourcemap: Turbopack expects an object, not a JSON string
+    let inMap = map
+    if (typeof inMap === 'string') {
+      try {
+        inMap = JSON.parse(inMap)
+      } catch (_) {
+        // ignore, treat as no map
+        inMap = undefined
+      }
+    }
+
+    // Do not process vendor code
+    if (/node_modules/.test(this.resourcePath)) return done(null, code, inMap)
+
+    // Parse with Babel (supports JSX and TypeScript)
+    const ast = parse(code, {
+      sourceType: 'module',
+      plugins: ['jsx', 'typescript'],
+      sourceFilename: this.resourcePath,
+    })
+
+    // MagicString allows non-destructive code edits and sourcemap generation
+    const ms = new MagicString(code)
+    const fileRelative = path.relative(this.rootContext, this.resourcePath)
+    
+
+    let mutated = false
+
+    // Add parent references to AST nodes for upward traversal (non-enumerable)
+    walk(ast, {
+      enter(node, parent) {
+        if (parent && !Object.prototype.hasOwnProperty.call(node, 'parent')) {
+          Object.defineProperty(node, 'parent', { value: parent, enumerable: false })
+        }
+      },
+    })
+
+    // Collect variable declarations first for later contextual tagging
+    const variables = findVariableDeclarations(ast)
+
+    // Gather local identifiers that reference `next/image` imports
+    const imageAliases = new Set()
+    walk(ast, {
+      enter(node) {
+        if (node.type === 'ImportDeclaration' && node.source.value === 'next/image') {
+          for (const spec of node.specifiers) imageAliases.add(spec.local.name)
+        }
+      },
+    })
+
+    // Inject attributes with enhanced semantic context
+    walk(ast, {
+      enter(node) {
+        
+        if (node.type !== 'JSXOpeningElement') return
+        const mapContext = findMapContext(node, variables)
+        const semanticName = getSemanticName(node, mapContext, imageAliases)
+
+       
+        // Respect blacklist and fragments
+        if (
+          !semanticName ||
+          ['Fragment', 'React.Fragment'].includes(semanticName) ||
+          (!isNextImageAlias(imageAliases, semanticName.split('-')[0]) && !shouldTag(semanticName))
+        )
+          return
+
+        // Use source location to build a stable identifier
+        const locStart = node.loc?.start
+        const line = locStart?.line ?? 0
+        const column = locStart?.column ?? 0
+        let acebuilderId = `${fileRelative}:${line}:${column}`
+
+        // Enhance the ID with context if we have map information
+        if (mapContext) acebuilderId += `@${mapContext.arrayName}`
+
+        // Append referenced variable names for simple identifier references in props
+        node.attributes?.forEach((attr) => {
+          if (
+            attr.type === 'JSXAttribute' &&
+            attr.value?.type === 'JSXExpressionContainer' &&
+            attr.value.expression?.type === 'Identifier'
+          ) {
+            const refName = attr.value.expression.name
+            const varInfo = variables.get(refName)
+            if (varInfo) acebuilderId += `@${refName}`
+          }
+        })
+
+        // If inside a map context and we have an index variable, inject data-map-index
+        if (mapContext?.indexVarName) {
+          ms.appendLeft(node.name.end, ` data-map-index={${mapContext.indexVarName}}`)
+        }
+
+        // Inject the AceBuilder data attributes
+        ms.appendLeft(
+          node.name.end,
+          ` data-acebuilder-id="${acebuilderId}" data-acebuilder-name="${semanticName}"`
+        )
+        mutated = true
+      },
+    })
+
+    // If we did not modify the code, reuse original code and incoming map
+    if (!mutated) return done(null, code, inMap)
+
+    const out = ms.toString()
+    // Create a plain RawSourceMap object for webpack/Turbopack
+    const mapStr = ms.generateMap({
+      hires: true,
+      source: this.resourcePath,
+      includeContent: true,
+      file: this.resourcePath,
+    }).toString()
+
+    const outMap = JSON.parse(mapStr)
+
+    done(null, out, outMap)
+  } catch (err) {
+    done(err)
+  }
+}
+
+module.exports = componentTagger

package/lib/utils.js

@@ -0,0 +1,210 @@
+'use strict'
+
+const { walk } = require('estree-walker')
+const { threeFiberElems, dreiElems } = require('./blacklists')
+
+/**
+ * Utilities used by the AceBuilder component tagger loader.
+ *
+ * This module provides:
+ * - Blacklist-aware checks to decide if a JSX element should be tagged.
+ * - Helpers to extract literal values from Babel AST nodes.
+ * - AST walkers to collect variable declarations and infer contextual information
+ *   like Array.map() usage to enrich tag metadata.
+ */
+
+/**
+ * Decide whether a given JSX tag name should be tagged based on known blacklists.
+ *
+ * @param {string} name - The JSX tag name (e.g., 'Button', 'div', 'mesh').
+ * @returns {boolean} True if the element should be tagged; false if it is blacklisted.
+ */
+const shouldTag = (name) => !threeFiberElems.includes(name) && !dreiElems.includes(name)
+
+/**
+ * Check whether a tag name corresponds to an alias imported from `next/image`.
+ *
+ * Example: `import Img from 'next/image'` then `Img` is an alias that should be
+ * treated as semantic `img` for tagging.
+ *
+ * @param {Set<string>} aliases - Local identifiers bound to `next/image` imports.
+ * @param {string} name - The tag name to test.
+ * @returns {boolean} True if the name is a `next/image` alias.
+ */
+const isNextImageAlias = (aliases, name) => aliases.has(name)
+
+/**
+ * Attempt to resolve a static literal value from a Babel AST expression node.
+ *
+ * Supported nodes:
+ * - StringLiteral, NumericLiteral, BooleanLiteral
+ * - TemplateLiteral (only when all parts resolve to literals)
+ * - ObjectExpression (non-computed keys, recursively resolves values)
+ * - ArrayExpression (maps each element; holes become undefined)
+ *
+ * Returns `undefined` when the value cannot be safely determined at build time.
+ *
+ * @param {import('@babel/types').Node | undefined} node
+ * @returns {unknown} The extracted literal value, or undefined.
+ */
+function extractLiteralValue(node) {
+  if (!node) return undefined
+  switch (node.type) {
+    case 'StringLiteral':
+      return node.value
+    case 'NumericLiteral':
+      return node.value
+    case 'BooleanLiteral':
+      return node.value
+    case 'TemplateLiteral': {
+      // Best-effort: only resolve when all quasis/expressions are static literals
+      try {
+        const parts = []
+        const { quasis, expressions } = node
+        for (let i = 0; i < quasis.length; i++) {
+          parts.push(quasis[i]?.value?.cooked ?? '')
+          if (i < expressions.length) {
+            const v = extractLiteralValue(expressions[i])
+            if (v === undefined) return undefined
+            parts.push(String(v))
+          }
+        }
+        return parts.join('')
+      } catch (_) {
+        return undefined
+      }
+    }
+    case 'ObjectExpression': {
+      const obj = {}
+      for (const prop of node.properties) {
+        if (prop.type === 'ObjectProperty' && !prop.computed) {
+          const key = prop.key.type === 'Identifier' ? prop.key.name : prop.key.value
+          obj[key] = extractLiteralValue(prop.value)
+        }
+      }
+      return obj
+    }
+    case 'ArrayExpression':
+      // Handle sparse arrays (holes) and map each element safely
+      return node.elements.map((el) => (el ? extractLiteralValue(el) : undefined))
+    default:
+      return undefined
+  }
+}
+
+/**
+ * Collect variable declarations from the AST and retain basic metadata
+ * that can be used later when building semantic IDs.
+ *
+ * For array literals, this also stores the array items for potential context.
+ *
+ * @param {import('@babel/types').File} ast - The parsed Babel AST.
+ * @returns {Map<string, { name: string, type: 'array'|'object'|'primitive', value: unknown, arrayItems?: unknown[], loc?: { line: number, column: number } }>} A map of variable info by name.
+ */
+function findVariableDeclarations(ast) {
+  const variables = new Map()
+  walk(ast, {
+    enter(node) {
+      if (node.type === 'VariableDeclaration') {
+        for (const declarator of node.declarations) {
+          if (declarator.id.type === 'Identifier' && declarator.init) {
+            const varName = declarator.id.name
+            const value = extractLiteralValue(declarator.init)
+            variables.set(varName, {
+              name: varName,
+              type: Array.isArray(value)
+                ? 'array'
+                : typeof value === 'object'
+                ? 'object'
+                : 'primitive',
+              value,
+              arrayItems: Array.isArray(value) ? value : undefined,
+              loc: declarator.loc?.start,
+            })
+          }
+        }
+      }
+    },
+  })
+  return variables
+}
+
+/**
+ * Ascend from a JSX node to detect whether it resides within an Array.map call.
+ * If found, extracts the source array name, callback parameter names, and related metadata.
+ *
+ * This information is used to add `data-map-index` and to enrich `data-acebuilder-id`.
+ *
+ * @param {import('@babel/types').Node & { parent?: any }} node - Current JSXOpeningElement node (with parent links).
+ * @param {Map<string, any>} variables - Variable metadata collected by findVariableDeclarations.
+ * @returns {null | { arrayName: string, itemVarName: string, arrayItems?: unknown[], arrayLoc?: { line: number, column: number }, indexVarName?: string }}
+ */
+function findMapContext(node, variables) {
+  // Walk up the tree to find if this JSX element is inside a map call
+  let current = node
+  let depth = 0
+  const maxDepth = 10
+  while (current && depth < maxDepth) {
+    if (
+      current.type === 'CallExpression' &&
+      current.callee?.type === 'MemberExpression' &&
+      current.callee?.property?.name === 'map'
+    ) {
+      const arrayName = current.callee.object?.name
+      const mapCallback = current.arguments?.[0]
+      if (
+        arrayName &&
+        (mapCallback?.type === 'ArrowFunctionExpression' || mapCallback?.type === 'FunctionExpression')
+      ) {
+        const itemParam = mapCallback.params?.[0]
+        const indexParam = mapCallback.params?.[1]
+        if (itemParam?.type === 'Identifier') {
+          const varInfo = variables.get(arrayName)
+          return {
+            arrayName,
+            itemVarName: itemParam.name,
+            arrayItems: varInfo?.arrayItems,
+            arrayLoc: varInfo?.loc,
+            indexVarName: indexParam?.type === 'Identifier' ? indexParam.name : undefined,
+          }
+        }
+      }
+    }
+    current = current.parent
+    depth++
+  }
+  return null
+}
+
+/**
+ * Derive a semantic name for a JSX element that will be used as `data-acebuilder-name`.
+ *
+ * - Converts `next/image` aliases to a standard 'img' tag for consistency.
+ * - Supports identifiers (e.g., `Button`) and member expressions (e.g., `UI.Card`).
+ *
+ * @param {import('@babel/types').JSXOpeningElement} node - JSX opening element.
+ * @param {ReturnType<typeof findMapContext>} _mapContext - Optional map context (unused here but reserved for future rules).
+ * @param {Set<string>} imageAliases - Local names that alias `next/image`.
+ * @returns {string | null} The semantic tag name or null if it cannot be determined.
+ */
+function getSemanticName(node, _mapContext, imageAliases) {
+  const getName = () => {
+    if (node.name.type === 'JSXIdentifier') return node.name.name
+    if (node.name.type === 'JSXMemberExpression')
+      return `${node.name.object.name}.${node.name.property.name}`
+    return null
+  }
+  const tagName = getName()
+  if (!tagName) return null
+  if (isNextImageAlias(imageAliases, tagName)) return 'img'
+  return tagName
+}
+
+module.exports = {
+  shouldTag,
+  isNextImageAlias,
+  extractLiteralValue,
+  findVariableDeclarations,
+  findMapContext,
+  getSemanticName,
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@acebuilder/component-tagger",
+  "version": "0.0.1",
+  "description": "Next.js webpack pre-loader to tag React components with AceBuilder metadata during development.",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./index.js",
+      "require": "./index.js",
+      "default": "./index.js",
+      "types": "./index.d.ts"
+    }
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "lib/**/*"
+  ],
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "acebuilder"
+  ],
+  "dependencies": {
+    "@babel/parser": "^7.28.4",
+    "estree-walker": "2.0.2",
+    "magic-string": "^0.30.19",
+    "source-map": "^0.7.0"
+  }
+}