@contentful/experience-design-system-extraction 2.34.5-dev-build-4a4b9e84.0 → 2.34.5-dev-build-9dff4380.0

package/dist/src/extract/{adapters/react/extractor.js → react.js}

@@ -1,11 +1,9 @@
 import { Node, SyntaxKind, } from 'ts-morph';
-import { extractAllowedValues, getNodeDefinitions, getTypeReferenceName, getTypeTargetDeclarations, getJsxTagNameNode, extractTsxComponents, getRenderableExports, } from '../support/tsx-shared.js';
-import { shouldBeSlot } from '../../evidence/slot-evidence.js';
-import { extractAllowedComponentsFromTypeText, extractAllowedComponentsFromJsdoc, } from '../../evidence/allowed-components.js';
-import { getSourceLineMetadata } from '../support/resolution/source-location.js';
-import { collectTypePredicateComponentReferences, collectRuntimeTypeCheckComponentReferences, collectRenderedComponentReferences, collectArrayMapRenderComponentReferences, } from '../../evidence/structural-slot-evidence.js';
-import { collectPropDataflow, getComponentIdentity } from './prop-dataflow.js';
-import { resolveBestFunctionNode } from './function-resolution.js';
+import { extractAllowedValues, getNodeDefinitions, getTypeReferenceName, getTypeTargetDeclarations, getValueTargetDeclarations, getJsxTagNameNode, extractTsxComponents, getRenderableExports, isIntrinsicJsxElement, } from './tsx-shared.js';
+import { shouldBeSlot } from './slot-detection.js';
+import { extractAllowedComponentsFromTypeText, extractAllowedComponentsFromJsdoc } from './slot-allowed-components.js';
+import { getSourceLineMetadata } from './source-line-metadata.js';
+import { collectTypePredicateComponentReferences, collectRuntimeTypeCheckComponentReferences, collectRenderedComponentReferences, collectArrayMapRenderComponentReferences, } from './structural-slot-evidence.js';
 const REACT_ELEMENT_GENERIC_TEST = /(?:React\.)?ReactElement\s*<\s*[A-Za-z_$][\w$.]*/;
 function isReactElementGenericSlotType(typeText) {
     return REACT_ELEMENT_GENERIC_TEST.test(typeText);
@@ -819,6 +817,223 @@ function filterImplementationOnlyAliasProps(props, func) {
         return !isImplementationOnlyAliasProp(func, prop.name);
     });
 }
+function getDeclarationIdentity(node) {
+    if (Node.isIdentifier(node)) {
+        const parent = node.getParent();
+        if ((Node.isVariableDeclaration(parent) || Node.isBindingElement(parent) || Node.isParameterDeclaration(parent)) &&
+            parent.getNameNode() === node) {
+            return parent;
+        }
+    }
+    return getNodeDefinitions(node)[0]?.getDeclarationNode() ?? node;
+}
+function getComponentIdentity(func) {
+    return `${func.getSourceFile().getFilePath()}:${func.getStart()}`;
+}
+function resolveForwardedComponentIdentity(tagNameNode) {
+    if (!Node.isIdentifier(tagNameNode))
+        return undefined;
+    for (const declaration of getValueTargetDeclarations(tagNameNode)) {
+        const func = resolveFunctionNode(declaration);
+        if (func)
+            return getComponentIdentity(func);
+    }
+    return undefined;
+}
+/**
+ * Declarations that are rebound somewhere in the body, so their initializer no
+ * longer describes the value that reaches JSX.
+ */
+function collectReboundDeclarations(body) {
+    const rebound = new Set();
+    const recordTarget = (target) => {
+        if (Node.isIdentifier(target)) {
+            rebound.add(getDeclarationIdentity(target));
+            return;
+        }
+        if ((Node.isPropertyAccessExpression(target) || Node.isElementAccessExpression(target)) &&
+            Node.isIdentifier(target.getExpression())) {
+            rebound.add(getDeclarationIdentity(target.getExpression()));
+        }
+    };
+    for (const assignment of body?.getDescendantsOfKind(SyntaxKind.BinaryExpression) ?? []) {
+        // Covers `=` and every compound form (`+=`, `??=`, `>>>=`, ...).
+        const operator = assignment.getOperatorToken().getKind();
+        if (operator < SyntaxKind.FirstAssignment || operator > SyntaxKind.LastAssignment)
+            continue;
+        recordTarget(assignment.getLeft());
+    }
+    // Only `++`/`--` rebind the operand. Reading a prop through `!`, `-`, `+`, or
+    // `~` leaves the alias intact, so those operators must not invalidate it.
+    for (const update of body?.getDescendantsOfKind(SyntaxKind.PrefixUnaryExpression) ?? []) {
+        const operator = update.getOperatorToken();
+        if (operator !== SyntaxKind.PlusPlusToken && operator !== SyntaxKind.MinusMinusToken)
+            continue;
+        recordTarget(update.getOperand());
+    }
+    for (const update of body?.getDescendantsOfKind(SyntaxKind.PostfixUnaryExpression) ?? []) {
+        recordTarget(update.getOperand());
+    }
+    return rebound;
+}
+/** Trace only statically resolvable, component-local prop dataflow into JSX. */
+function collectPropDataflow(func, param, availablePropNames) {
+    const valueAliases = new Map();
+    const objectAliases = new Map();
+    const fullPropsShape = new Map([...availablePropNames].map((name) => [name, name]));
+    const belongsToComponentFunction = (node) => node.getFirstAncestor((ancestor) => Node.isFunctionDeclaration(ancestor) || Node.isArrowFunction(ancestor) || Node.isFunctionExpression(ancestor)) === func;
+    const resolveValue = (expression) => {
+        if (!expression)
+            return undefined;
+        if (Node.isParenthesizedExpression(expression))
+            return resolveValue(expression.getExpression());
+        if (Node.isIdentifier(expression))
+            return valueAliases.get(getDeclarationIdentity(expression));
+        if (Node.isPropertyAccessExpression(expression)) {
+            const object = expression.getExpression();
+            return Node.isIdentifier(object)
+                ? objectAliases.get(getDeclarationIdentity(object))?.get(expression.getName())
+                : undefined;
+        }
+        if (Node.isElementAccessExpression(expression)) {
+            const argument = expression.getArgumentExpression();
+            if (!argument || (!Node.isStringLiteral(argument) && !Node.isNoSubstitutionTemplateLiteral(argument))) {
+                return undefined;
+            }
+            const object = expression.getExpression();
+            return Node.isIdentifier(object)
+                ? objectAliases.get(getDeclarationIdentity(object))?.get(argument.getLiteralText())
+                : undefined;
+        }
+        return undefined;
+    };
+    const resolveObject = (expression) => {
+        if (!expression)
+            return undefined;
+        if (Node.isParenthesizedExpression(expression))
+            return resolveObject(expression.getExpression());
+        if (Node.isIdentifier(expression))
+            return objectAliases.get(getDeclarationIdentity(expression));
+        if (!Node.isObjectLiteralExpression(expression))
+            return undefined;
+        const shape = new Map();
+        for (const property of expression.getProperties()) {
+            if (Node.isSpreadAssignment(property)) {
+                const spreadShape = resolveObject(property.getExpression());
+                for (const [targetProp, sourceProp] of spreadShape ?? [])
+                    shape.set(targetProp, sourceProp);
+            }
+            else if (Node.isShorthandPropertyAssignment(property)) {
+                const sourceProp = resolveValue(property.getNameNode());
+                if (sourceProp)
+                    shape.set(property.getName(), sourceProp);
+            }
+            else if (Node.isPropertyAssignment(property)) {
+                const propertyNameNode = property.getNameNode();
+                if (!Node.isIdentifier(propertyNameNode) && !Node.isStringLiteral(propertyNameNode))
+                    continue;
+                const sourceProp = resolveValue(property.getInitializer());
+                if (sourceProp)
+                    shape.set(property.getName(), sourceProp);
+            }
+        }
+        return shape;
+    };
+    const addBindings = (pattern, sourceShape) => {
+        const omittedProps = new Set(pattern
+            .getElements()
+            .filter((element) => !element.getDotDotDotToken())
+            .map((element) => element.getPropertyNameNode()?.getText() ?? element.getNameNode().getText()));
+        for (const element of pattern.getElements()) {
+            const localName = element.getNameNode();
+            if (!Node.isIdentifier(localName))
+                continue;
+            if (element.getDotDotDotToken()) {
+                objectAliases.set(getDeclarationIdentity(localName), new Map([...sourceShape].filter(([targetProp]) => !omittedProps.has(targetProp))));
+                continue;
+            }
+            const targetProp = element.getPropertyNameNode()?.getText() ?? localName.getText();
+            const sourceProp = sourceShape.get(targetProp);
+            if (sourceProp)
+                valueAliases.set(getDeclarationIdentity(localName), sourceProp);
+        }
+    };
+    const paramNameNode = param.getNameNode();
+    if (Node.isIdentifier(paramNameNode))
+        objectAliases.set(getDeclarationIdentity(paramNameNode), fullPropsShape);
+    else if (Node.isObjectBindingPattern(paramNameNode))
+        addBindings(paramNameNode, fullPropsShape);
+    const body = func.getBody();
+    const reboundDeclarations = collectReboundDeclarations(body);
+    for (const declaration of reboundDeclarations) {
+        valueAliases.delete(declaration);
+        objectAliases.delete(declaration);
+    }
+    for (const declaration of body?.getDescendantsOfKind(SyntaxKind.VariableDeclaration) ?? []) {
+        if (!belongsToComponentFunction(declaration))
+            continue;
+        const initializer = declaration.getInitializer();
+        const declarationName = declaration.getNameNode();
+        if (Node.isIdentifier(declarationName)) {
+            const aliasDeclaration = getDeclarationIdentity(declarationName);
+            if (reboundDeclarations.has(aliasDeclaration))
+                continue;
+            const sourceProp = resolveValue(initializer);
+            if (sourceProp)
+                valueAliases.set(aliasDeclaration, sourceProp);
+            const sourceShape = resolveObject(initializer);
+            if (sourceShape)
+                objectAliases.set(aliasDeclaration, new Map(sourceShape));
+        }
+        else if (Node.isObjectBindingPattern(declarationName)) {
+            const sourceShape = resolveObject(initializer);
+            if (sourceShape) {
+                const hasInvalidatedBinding = declarationName
+                    .getElements()
+                    .some((element) => reboundDeclarations.has(getDeclarationIdentity(element.getNameNode())));
+                if (!hasInvalidatedBinding)
+                    addBindings(declarationName, sourceShape);
+            }
+        }
+    }
+    const intrinsicDomProps = new Set();
+    const componentEdges = [];
+    const recordForwarding = (tagNameNode, targetProp, sourceProp) => {
+        const tagName = tagNameNode.getText();
+        if (isIntrinsicJsxElement(tagName)) {
+            if (targetProp === sourceProp)
+                intrinsicDomProps.add(sourceProp);
+            return;
+        }
+        const targetComponentIdentity = resolveForwardedComponentIdentity(tagNameNode);
+        if (targetComponentIdentity)
+            componentEdges.push({ sourceProp, targetComponentIdentity, targetProp });
+    };
+    for (const attribute of func.getDescendantsOfKind(SyntaxKind.JsxAttribute)) {
+        if (!belongsToComponentFunction(attribute))
+            continue;
+        const tagNameNode = getJsxTagNameNode(attribute);
+        if (!tagNameNode)
+            continue;
+        const initializer = attribute.getInitializer();
+        if (!initializer || !Node.isJsxExpression(initializer))
+            continue;
+        const sourceProp = resolveValue(initializer.getExpression());
+        if (sourceProp)
+            recordForwarding(tagNameNode, attribute.getNameNode().getText(), sourceProp);
+    }
+    for (const spread of func.getDescendantsOfKind(SyntaxKind.JsxSpreadAttribute)) {
+        if (!belongsToComponentFunction(spread))
+            continue;
+        const tagNameNode = getJsxTagNameNode(spread);
+        if (!tagNameNode)
+            continue;
+        const shape = resolveObject(spread.getExpression());
+        for (const [targetProp, sourceProp] of shape ?? [])
+            recordForwarding(tagNameNode, targetProp, sourceProp);
+    }
+    return { intrinsicDomProps, componentEdges };
+}
 function extractDestructuredBindingFallbackProps(func, param, existingPropNames, slotNames) {
     const nameNode = param.getNameNode();
     const bindingPatterns = [];
@@ -1448,8 +1663,8 @@ export async function extractReactComponents(filePaths) {
             }
         }
     }
-    // Structural evidence (usage, not a declared slot contract) — see the
-    // structural slot evidence pass. Only fills slots the typed-slot pass above
+    // Structural evidence (usage, not a declared slot contract) — see
+    // structural-slot-evidence.ts. Only fills slots the typed-slot pass above
     // found nothing for; a declared contract always takes precedence. File-wide
     // signals (type-predicate functions, `.type === Component` identity checks)
     // are computed once per file and shared across every component in it, since
@@ -1723,3 +1938,132 @@ function extractPropTypes(sourceFile, componentName) {
     }
     return undefined;
 }
+function resolveFunctionNode(decl) {
+    if (Node.isFunctionDeclaration(decl))
+        return decl;
+    if (Node.isArrowFunction(decl))
+        return decl;
+    if (Node.isFunctionExpression(decl))
+        return decl;
+    if (Node.isVariableDeclaration(decl)) {
+        const init = decl.getInitializer();
+        if (init && Node.isArrowFunction(init))
+            return init;
+        if (init && Node.isFunctionExpression(init))
+            return init;
+        if (init && Node.isCallExpression(init))
+            return resolveFunctionFromCallExpression(init, new Set());
+    }
+    return undefined;
+}
+function resolveBestFunctionNode(declarations) {
+    const candidates = declarations
+        .map((decl) => resolveFunctionNode(decl))
+        .filter((candidate) => candidate !== undefined);
+    const implementation = candidates.find((candidate) => !Node.isFunctionDeclaration(candidate) || candidate.getBody() !== undefined);
+    return implementation ?? candidates[0];
+}
+function resolveForwardRefFunction(callExpr) {
+    if (!Node.isCallExpression(callExpr))
+        return undefined;
+    const expressionText = callExpr.getExpression().getText();
+    if (!/(^|\.)forwardRef$/.test(expressionText))
+        return undefined;
+    const firstArg = callExpr.getArguments()[0];
+    if (!firstArg)
+        return undefined;
+    if (Node.isArrowFunction(firstArg))
+        return firstArg;
+    if (Node.isFunctionExpression(firstArg))
+        return firstArg;
+    if (Node.isIdentifier(firstArg)) {
+        const declarations = getNodeDefinitions(firstArg).flatMap((definition) => {
+            const declarationNode = definition.getDeclarationNode();
+            return declarationNode ? [declarationNode] : [];
+        });
+        for (const declaration of declarations) {
+            const resolved = resolveFunctionNode(declaration);
+            if (resolved)
+                return resolved;
+        }
+    }
+    return undefined;
+}
+function resolveFunctionFromCallExpression(callExpr, seen) {
+    return resolveForwardRefFunction(callExpr) ?? resolveReturnedFunctionFromFactoryCall(callExpr, seen);
+}
+function resolveReturnedFunctionFromFactoryCall(callExpr, seen) {
+    const expression = callExpr.getExpression();
+    if (!Node.isIdentifier(expression))
+        return undefined;
+    for (const definition of getNodeDefinitions(expression)) {
+        const declaration = definition.getDeclarationNode();
+        if (!declaration)
+            continue;
+        const resolved = resolveReturnedFunctionFromDeclaration(declaration, seen);
+        if (resolved)
+            return resolved;
+    }
+    return undefined;
+}
+function resolveReturnedFunctionFromDeclaration(node, seen) {
+    if (seen.has(node))
+        return undefined;
+    seen.add(node);
+    if (Node.isVariableDeclaration(node)) {
+        const initializer = node.getInitializer();
+        if (!initializer)
+            return undefined;
+        if (Node.isArrowFunction(initializer) || Node.isFunctionExpression(initializer)) {
+            return resolveReturnedFunctionFromCallable(initializer, seen);
+        }
+        if (Node.isCallExpression(initializer)) {
+            return resolveFunctionFromCallExpression(initializer, seen);
+        }
+        return undefined;
+    }
+    if (Node.isFunctionDeclaration(node) || Node.isFunctionExpression(node) || Node.isArrowFunction(node)) {
+        return resolveReturnedFunctionFromCallable(node, seen);
+    }
+    return undefined;
+}
+function resolveReturnedFunctionFromCallable(fn, seen) {
+    const body = fn.getBody();
+    if (!body)
+        return undefined;
+    if (!Node.isBlock(body)) {
+        return resolveReturnedFunctionFromExpression(body, seen);
+    }
+    for (const statement of body.getStatements()) {
+        if (!Node.isReturnStatement(statement))
+            continue;
+        const expression = statement.getExpression();
+        if (!expression)
+            continue;
+        const resolved = resolveReturnedFunctionFromExpression(expression, seen);
+        if (resolved)
+            return resolved;
+    }
+    return undefined;
+}
+function resolveReturnedFunctionFromExpression(node, seen) {
+    if (Node.isArrowFunction(node) || Node.isFunctionExpression(node))
+        return node;
+    if (Node.isParenthesizedExpression(node)) {
+        return resolveReturnedFunctionFromExpression(node.getExpression(), seen);
+    }
+    if (Node.isCallExpression(node)) {
+        return resolveFunctionFromCallExpression(node, seen);
+    }
+    if (Node.isIdentifier(node)) {
+        for (const definition of getNodeDefinitions(node)) {
+            const declaration = definition.getDeclarationNode();
+            if (!declaration)
+                continue;
+            const resolved = resolveReturnedFunctionFromDeclaration(declaration, seen);
+            if (resolved)
+                return resolved;
+        }
+    }
+    return undefined;
+}

package/dist/src/extract/scoring.d.ts

@@ -0,0 +1,12 @@
+import type { RawComponentDefinition } from '../types.js';
+export type ExtractionConfidence = 1 | 2 | 3 | 4 | 5;
+export type ExtractionScore = {
+    confidence: ExtractionConfidence;
+    reasons: string[];
+};
+export interface ExtractionScoreOptions {
+    additionalIssueCount?: number;
+    additionalReasons?: string[];
+}
+export declare function computeExtractionScore(component: RawComponentDefinition, options?: ExtractionScoreOptions): ExtractionScore;
+export declare function deriveNeedsReview(confidence: ExtractionConfidence): boolean;

package/dist/src/extract/{policies/quality/scoring.js → scoring.js}

@@ -1,4 +1,3 @@
-// 1 = very low confidence (likely wrong), 5 = very high confidence (clearly correct)
 // Prop type strings that indicate the extractor couldn't resolve a concrete type
 const OPAQUE_TYPES = new Set(['any', 'unknown', 'object', 'Record<string, unknown>', 'Record<string, any>']);
 // Prop names that are non-obvious and benefit from a description

package/dist/src/extract/{policies/quality/source-inspection.d.ts → source-inspection.d.ts}

@@ -1,4 +1,4 @@
-import type { RawComponentDefinition } from '../../model/component.js';
+import type { RawComponentDefinition } from '../types.js';
 export declare const HIGH_CONFIDENCE_DATA_FETCH_WRAPPER_REASON = "data-fetch-wrapper";
 export declare const POSSIBLE_DATA_FETCH_WRAPPER_REASON = "possible-data-fetch-wrapper";
 export declare const ZERO_SURFACE_RENDERED_UI_REASON = "zero-surface:rendered-ui";

package/dist/src/extract/{policies/quality/source-inspection.js → source-inspection.js}

@@ -1,5 +1,5 @@
 import { readFile } from 'node:fs/promises';
-import { parseImportedNames } from '../../evidence/source-evidence.js';
+import { parseImportedNames } from './parse-imported-names.js';
 export const HIGH_CONFIDENCE_DATA_FETCH_WRAPPER_REASON = 'data-fetch-wrapper';
 export const POSSIBLE_DATA_FETCH_WRAPPER_REASON = 'possible-data-fetch-wrapper';
 export const ZERO_SURFACE_RENDERED_UI_REASON = 'zero-surface:rendered-ui';

package/dist/src/extract/{adapters/support/resolution/source-location.d.ts → source-line-metadata.d.ts}

@@ -1,3 +1,3 @@
 import type { Node } from 'ts-morph';
-import type { RawPropDefinition } from '../../../model/component.js';
+import type { RawPropDefinition } from '../types.js';
 export declare function getSourceLineMetadata(declaration: Node | undefined): Pick<RawPropDefinition, 'sourceStartLine' | 'sourceEndLine'>;

package/dist/src/extract/{adapters/stencil/extractor.d.ts → stencil.d.ts}

@@ -1,2 +1,2 @@
-import type { ComponentExtractionResult } from '../../model/component.js';
+import type { ComponentExtractionResult } from '../types.js';
 export declare function extractStencilComponents(filePaths: string[]): Promise<ComponentExtractionResult>;

package/dist/src/extract/{adapters/stencil/extractor.js → stencil.js}

@@ -1,7 +1,6 @@
 import { Project, Node, SyntaxKind } from 'ts-morph';
-import { getJsxTagNameNode, isIntrinsicJsxElement, kebabToPascal } from '../support/tsx-shared.js';
-import { createSortedExtractionResult } from '../support/file-processing/result-normalizer.js';
-import { extractProjectSourceFiles } from '../support/file-processing/project-source-files.js';
+import { getJsxTagNameNode, isIntrinsicJsxElement, kebabToPascal } from './tsx-shared.js';
+import { createSortedExtractionResult, extractProjectSourceFiles } from './file-extraction-workers.js';
 function isStencilFile(sourceFile) {
     return sourceFile.getImportDeclarations().some((imp) => imp.getModuleSpecifierValue() === '@stencil/core');
 }

package/dist/src/extract/{evidence/structural-slot-evidence.d.ts → structural-slot-evidence.d.ts}

@@ -1,5 +1,5 @@
 import { type FunctionDeclaration, type ArrowFunction, type FunctionExpression, type SourceFile } from 'ts-morph';
-import { type AllowedComponentsContext } from './allowed-components.js';
+import { type AllowedComponentsContext } from './slot-allowed-components.js';
 type FunctionLike = FunctionDeclaration | ArrowFunction | FunctionExpression;
 /**
  * Structural composition evidence: parent→child relationships a component's

package/dist/src/extract/{evidence/structural-slot-evidence.js → structural-slot-evidence.js}

@@ -1,6 +1,6 @@
 import { Node, SyntaxKind, } from 'ts-morph';
-import { extractAllowedComponentsFromTypeText } from './allowed-components.js';
-import { isIntrinsicJsxElement } from '../adapters/support/tsx-shared.js';
+import { extractAllowedComponentsFromTypeText } from './slot-allowed-components.js';
+import { isIntrinsicJsxElement } from './tsx-shared.js';
 /**
  * Structural composition evidence: parent→child relationships a component's
  * source implies through *usage*, not through a declared slot contract

package/dist/src/extract/{adapters/svelte/extractor.d.ts → svelte.d.ts}

@@ -1,5 +1,4 @@
-import type { ComponentExtractionResult } from '../../model/component.js';
-import type { ExtractorOptions } from '../../model/options.js';
+import type { ComponentExtractionResult, ExtractorOptions } from '../types.js';
 export declare function extractSvelteComponents(filePaths: string[], onProgress?: (p: {
     filesProcessed: number;
     componentsFound: number;

package/dist/src/extract/{adapters/svelte/extractor.js → svelte.js}

@@ -1,15 +1,13 @@
 import os from 'node:os';
-import { dirname, resolve, join } from 'node:path';
+import { basename, dirname, resolve, join } from 'node:path';
 import { existsSync, readFileSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import { parse as parseSvelte } from 'svelte/compiler';
 import { Project, Node, ScriptTarget, ModuleKind, ts } from 'ts-morph';
-import { computeExtractionScore, deriveNeedsReview } from '../../policies/quality/scoring.js';
-import { extractAllowedComponentsFromTypeText } from '../../evidence/allowed-components.js';
-import { runFileExtractionWorkers } from '../support/file-processing/file-workers.js';
-import { resolveLocalModule } from '../support/resolution/local-module.js';
-import { getSvelteComponentName } from './identity.js';
-import { extractTemplateSlots, mergeSlots } from './slots.js';
+import { computeExtractionScore, deriveNeedsReview } from './scoring.js';
+import { extractAllowedComponentsFromTypeText } from './slot-allowed-components.js';
+import { runFileExtractionWorkers } from './file-extraction-workers.js';
+import { resolveLocalModule } from './resolve-local-module.js';
 export async function extractSvelteComponents(filePaths, onProgress, opts) {
     const svelteFiles = filePaths.filter((f) => f.endsWith('.svelte'));
     const retryContexts = new Map();
@@ -468,6 +466,31 @@ async function extractFromSvelteFile(filePath, source) {
     }
     return { component, warnings, ...(retryContext ? { retryContext } : {}) };
 }
+const ANATOMY_FOLDERS = new Set(['anatomy', 'parts']);
+function getSvelteComponentName(filePath) {
+    const file = basename(filePath, '.svelte');
+    const parentDir = basename(dirname(filePath));
+    if (file === 'index')
+        return toPascalCase(parentDir);
+    if (ANATOMY_FOLDERS.has(parentDir)) {
+        const grandparent = basename(dirname(dirname(filePath)));
+        if (grandparent && grandparent !== '.' && grandparent !== '/') {
+            return `${toPascalCase(grandparent)}${toPascalCase(file)}`;
+        }
+    }
+    return toPascalCase(file);
+}
+function toPascalCase(s) {
+    if (!s)
+        return s;
+    if (/^[A-Z]/.test(s) && !s.includes('-') && !s.includes('_'))
+        return s;
+    return s
+        .split(/[-_]+/)
+        .filter(Boolean)
+        .map((part) => part[0].toUpperCase() + part.slice(1))
+        .join('');
+}
 function hasV4ExportLetProps(instance) {
     const body = instance['content']?.['body'];
     if (!body)
@@ -1223,3 +1246,64 @@ function extractAllowedValuesFromText(typeText) {
     }
     return out.length > 0 ? out : undefined;
 }
+function extractTemplateSlots(fragment) {
+    const slots = [];
+    const seen = new Set();
+    walk(fragment);
+    return slots;
+    function walk(node) {
+        if (!node)
+            return;
+        if (node.type === 'SlotElement') {
+            const name = readSlotName(node);
+            if (!seen.has(name)) {
+                seen.add(name);
+                slots.push({ name, isDefault: name === 'default' });
+            }
+        }
+        const children = node['nodes'] ?? node['children'] ?? [];
+        for (const c of children)
+            walk(c);
+        const fragChild = node['fragment'];
+        if (fragChild)
+            walk(fragChild);
+    }
+}
+function readSlotName(slotEl) {
+    const attrs = slotEl['attributes'] ?? [];
+    for (const attr of attrs) {
+        if (attr['name'] !== 'name')
+            continue;
+        const value = attr['value'];
+        if (Array.isArray(value)) {
+            for (const v of value) {
+                if (v.type === 'Text' && typeof v['data'] === 'string')
+                    return v['data'];
+            }
+        }
+    }
+    return 'default';
+}
+function mergeSlots(fromSnippetProps, fromTemplate) {
+    if (fromSnippetProps.length === 0)
+        return { slots: fromTemplate, mixedWarning: false };
+    if (fromTemplate.length === 0)
+        return { slots: fromSnippetProps, mixedWarning: false };
+    const byName = new Map();
+    for (const s of fromSnippetProps)
+        byName.set(s.name, s);
+    const snippetHasDefault = fromSnippetProps.some((s) => s.isDefault);
+    let mixed = false;
+    for (const s of fromTemplate) {
+        if (s.isDefault && snippetHasDefault) {
+            mixed = true;
+            continue;
+        }
+        if (byName.has(s.name)) {
+            mixed = true;
+            continue;
+        }
+        byName.set(s.name, s);
+    }
+    return { slots: [...byName.values()], mixedWarning: mixed };
+}

package/dist/src/extract/{adapters/support/tsx-shared.d.ts → tsx-shared.d.ts}

@@ -1,5 +1,5 @@
 import { Node, Project, type SourceFile, type Type } from 'ts-morph';
-import type { ExtractionExclusion } from '../../model/component.js';
+import type { ExtractionExclusion } from '../types.js';
 export declare function getTsxExtractionContext(filePaths: string[], componentFilePattern: RegExp): {
     componentFiles: string[];
     project: Project;

package/dist/src/extract/{policies/quality/validation.d.ts → validate.d.ts}

@@ -1,4 +1,4 @@
-import type { RawComponentDefinition, ExtractionValidationIssue } from '../../model/component.js';
+import type { RawComponentDefinition, ExtractionValidationIssue } from '../types.js';
 export declare function validateExtractedComponents(components: RawComponentDefinition[]): RawComponentDefinition[];
 export declare function shouldExcludeDueToValidation(component: RawComponentDefinition): boolean;
 /**

package/dist/src/extract/{adapters/vue-tsx/extractor.d.ts → vue-tsx.d.ts}

@@ -1,2 +1,2 @@
-import type { ComponentExtractionResult } from '../../model/component.js';
+import type { ComponentExtractionResult } from '../types.js';
 export declare function extractVueTsxComponents(filePaths: string[]): Promise<ComponentExtractionResult>;

package/dist/src/extract/{adapters/vue-tsx/extractor.js → vue-tsx.js}

@@ -1,5 +1,5 @@
 import { Node, SyntaxKind } from 'ts-morph';
-import { extractAllowedValues, extractTsxComponents, getTypeReferenceName, getTypeTargetDeclarations, getValueTargetDeclarations, getRenderableExports, } from '../support/tsx-shared.js';
+import { extractAllowedValues, extractTsxComponents, getTypeReferenceName, getTypeTargetDeclarations, getValueTargetDeclarations, getRenderableExports, } from './tsx-shared.js';
 export async function extractVueTsxComponents(filePaths) {
     const { components, warnings, exclusions } = extractTsxComponents(filePaths, /\.tsx$/, extractFromSourceFile);
     return {

package/dist/src/extract/{adapters/vue/extractor.d.ts → vue.d.ts}

@@ -1,4 +1,4 @@
-import type { ComponentExtractionResult } from '../../model/component.js';
+import type { ComponentExtractionResult } from '../types.js';
 export declare function extractVueComponents(filePaths: string[], onProgress?: (p: {
     filesProcessed: number;
     componentsFound: number;

package/dist/src/extract/{adapters/vue/extractor.js → vue.js}

@@ -4,10 +4,9 @@ import { readFile } from 'node:fs/promises';
 import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
 import { parse as parseSFC } from '@vue/compiler-sfc';
 import { Project, Node } from 'ts-morph';
-import { runFileExtractionWorkers } from '../support/file-processing/file-workers.js';
-import { createSortedExtractionResult } from '../support/file-processing/result-normalizer.js';
-import { resolveLocalModule } from '../support/resolution/local-module.js';
-import { resolveTypeProperty } from '../support/resolution/type-property.js';
+import { createSortedExtractionResult, runFileExtractionWorkers } from './file-extraction-workers.js';
+import { resolveLocalModule } from './resolve-local-module.js';
+import { resolveTypeProperty } from './resolve-type-property.js';
 // @vue/compiler-core NodeTypes enum values (stable since Vue 3.0)
 const ELEMENT_TYPE = 1;
 const ATTRIBUTE_TYPE = 6;

package/dist/src/extract/{adapters/web-components/extractor.d.ts → web-components.d.ts}

@@ -1,2 +1,2 @@
-import type { ComponentExtractionResult } from '../../model/component.js';
+import type { ComponentExtractionResult } from '../types.js';
 export declare function extractWebComponentDefinitions(filePaths: string[]): Promise<ComponentExtractionResult>;