canicode 0.10.5 → 0.11.1

package/dist/index.js

@@ -6,7 +6,7 @@ import 'crypto';
 import { homedir } from 'os';
 
 // package.json
-var version = "0.10.5";
+var version = "0.11.1";
 var SeveritySchema = z.enum([
   "blocking",
   "risk",
@@ -25,6 +25,15 @@ var SEVERITY_LABELS = {
   "missing-info": "Missing Info",
   suggestion: "Suggestion"
 };
+var DetectionSchema = z.literal("rule-based");
+var OutputChannelSchema = z.enum(["score", "annotation"]);
+var PersistenceIntentSchema = z.enum(["transient", "durable"]);
+var RulePurposeSchema = z.enum(["violation", "info-collection"]);
+var AnalysisScopeSchema = z.enum(["page", "component"]);
+var COMPONENT_SCOPE_ROOT_TYPES = /* @__PURE__ */ new Set(["COMPONENT", "COMPONENT_SET", "INSTANCE"]);
+function detectAnalysisScope(rootNode) {
+  return COMPONENT_SCOPE_ROOT_TYPES.has(rootNode.type) ? "component" : "page";
+}
 var CategorySchema = z.enum([
   "pixel-critical",
   "responsive-critical",
@@ -294,6 +303,16 @@ var CategoryScoreResultSchema = z.object({
 });
 var McpIssueSchema = z.object({
   ruleId: z.string(),
+  detection: DetectionSchema,
+  outputChannel: OutputChannelSchema.extract(["score"]),
+  persistenceIntent: PersistenceIntentSchema.extract(["transient"]),
+  /**
+   * #406: Whether the triggering rule's primary output is a score penalty
+   * (`violation`) or a gotcha annotation (`info-collection`). MCP consumers
+   * use this to decide whether the issue is actionable ("fix this") or
+   * annotation-seeking ("tell us what you meant here").
+   */
+  purpose: RulePurposeSchema,
   subType: z.string().optional(),
   severity: SeveritySchema,
   nodeId: z.string(),
@@ -307,6 +326,14 @@ var McpAnalyzeResponseSchema = z.object({
   fileName: z.string(),
   nodeCount: z.number().int().min(0),
   maxDepth: z.number().int().min(0),
+  /**
+   * #404: Resolved analysis scope (`page` vs `component`). Downstream
+   * consumers (e.g. `figma-implement-design`, gotcha UI) branch on this
+   * the same way rules do — a component-scope result should not be
+   * treated as if container bounds are missing, and repetition detection
+   * on a component-scope result is not meaningful.
+   */
+  scope: AnalysisScopeSchema,
   issueCount: z.number().int().min(0),
   isReadyForCodeGen: z.boolean(),
   blockingIssueCount: z.number().int().min(0),
@@ -339,10 +366,28 @@ var RuleApplyStrategySchema = z.enum([
 ]);
 var TargetPropertySchema = z.union([z.string(), z.array(z.string())]);
 var AnnotationPropertySchema = z.object({ type: z.string() });
+var GotchaDetectionSchema = DetectionSchema;
+var GotchaOutputChannelSchema = OutputChannelSchema.extract([
+  "annotation"
+]);
+var GotchaPersistenceIntentSchema = PersistenceIntentSchema.extract([
+  "durable"
+]);
 var GotchaSurveyQuestionSchema = z.object({
   nodeId: z.string(),
   nodeName: z.string(),
   ruleId: z.string(),
+  detection: GotchaDetectionSchema,
+  outputChannel: GotchaOutputChannelSchema,
+  persistenceIntent: GotchaPersistenceIntentSchema,
+  /**
+   * #406: Classifies the triggering rule as `violation` (score-primary,
+   * gotcha secondary) or `info-collection` (annotation-primary, score
+   * minimal). Consumers use this to prioritize answers that collect durable
+   * implementation context over answers that merely describe how to fix a
+   * violation the rule will stop firing for.
+   */
+  purpose: RulePurposeSchema,
   severity: SeveritySchema,
   question: z.string(),
   hint: z.string(),
@@ -434,6 +479,41 @@ var RULE_ID_CATEGORY = {
   "non-semantic-name": "semantic",
   "inconsistent-naming-convention": "semantic"
 };
+var RULE_PURPOSE = {
+  // Pixel Critical
+  "no-auto-layout": "violation",
+  "absolute-position-in-auto-layout": "violation",
+  "non-layout-container": "violation",
+  // Responsive Critical
+  "fixed-size-in-auto-layout": "violation",
+  // #403: missing-size-constraint reframed as info-collection. The rule
+  // fires on width chains whose intent is structurally undecidable
+  // (FILL container with no chain-bound ancestor; FIXED component or
+  // instance root). The gotcha question is the primary signal; the
+  // -1 score is just enough to keep the rule visible in
+  // diversity scoring without driving grade swings on its own.
+  "missing-size-constraint": "info-collection",
+  // Code Quality
+  "missing-component": "violation",
+  "detached-instance": "violation",
+  "variant-structure-mismatch": "violation",
+  "deep-nesting": "violation",
+  // Token Management
+  "raw-value": "violation",
+  "irregular-spacing": "violation",
+  // Interaction — gotcha-primary: Figma cannot encode "what happens on
+  // click" or "which states exist" in a way downstream code generation can
+  // consume. Rules fire to trigger the annotation, not to flag a violation.
+  "missing-interaction-state": "info-collection",
+  "missing-prototype": "info-collection",
+  // Semantic
+  "non-standard-naming": "violation",
+  "non-semantic-name": "violation",
+  "inconsistent-naming-convention": "violation"
+};
+function getRulePurpose(ruleId) {
+  return RULE_PURPOSE[ruleId] ?? "violation";
+}
 var RULE_CONFIGS = {
   // ── Pixel Critical ──
   "no-auto-layout": {
@@ -461,8 +541,12 @@ var RULE_CONFIGS = {
     enabled: true
   },
   "missing-size-constraint": {
-    severity: "risk",
-    score: -8,
+    // #403: severity downgraded `risk → missing-info` and score from
+    // -8 → -1 to match the new info-collection purpose. Keeping the
+    // rule enabled (not disabled) so its gotchas still surface in the
+    // survey — see RULE_PURPOSE entry above for the full rationale.
+    severity: "missing-info",
+    score: -1,
     enabled: true
   },
   // ── Code Quality ──
@@ -509,17 +593,22 @@ var RULE_CONFIGS = {
     }
   },
   // ── Interaction ──
+  // #406: both rules are `info-collection` — primary output is the gotcha
+  // annotation, not the score. Severity is `missing-info` so they surface in
+  // the gotcha survey (see `generateGotchaSurvey`) even though the penalty
+  // is minimal. Score stays at -1 so re-enabling `missing-prototype` on
+  // fixtures that lack `interactionDestinations` (#139) cannot swing grades.
   "missing-interaction-state": {
-    severity: "suggestion",
+    severity: "missing-info",
     score: -1,
     // uncalibrated: no metric to validate score (#210), kept at -1 to preserve category visibility
     enabled: true
   },
   "missing-prototype": {
     severity: "missing-info",
-    score: -3,
-    enabled: false
-    // disabled: interactionDestinations data missing from fixtures (#139)
+    score: -1,
+    // #406: info-collection — annotation is primary output; score kept minimal so #139 fixtures don't skew calibration
+    enabled: true
   },
   // ── Semantic ──
   "non-standard-naming": {
@@ -587,7 +676,11 @@ function getConfigsWithPreset(preset) {
 }
 var RULE_ANNOTATION_PROPERTIES = {
   "missing-size-constraint": {
-    default: [{ type: "width" }, { type: "height" }]
+    // #403: width-only — the redesigned rule does not evaluate the
+    // height axis (deferred follow-up). Emitting a `height` annotation
+    // here would mark properties the rule never inspected and confuse
+    // downstream Dev Mode hints.
+    default: [{ type: "width" }]
   },
   "irregular-spacing": {
     bySubType: {
@@ -639,6 +732,14 @@ var RuleRegistry = class {
   register(rule) {
     this.rules.set(rule.definition.id, rule);
   }
+  /**
+   * Remove a rule by ID. Primarily used by tests that register a
+   * throwaway rule and need to restore the registry afterwards. Returns
+   * `true` if the rule was present.
+   */
+  unregister(id) {
+    return this.rules.delete(id);
+  }
   /**
    * Get a rule by ID
    */
@@ -690,9 +791,27 @@ function defineRule(rule) {
   ruleRegistry.register(rule);
   return rule;
 }
+var AcknowledgmentIntentSchema = z.object({
+  field: z.string(),
+  value: z.unknown(),
+  scope: z.enum(["instance", "definition"])
+});
+var AcknowledgmentSceneWriteOutcomeSchema = z.object({
+  result: z.enum([
+    "succeeded",
+    "silent-ignored",
+    "api-rejected",
+    "user-declined-propagation",
+    "unknown"
+  ]),
+  reason: z.string().optional()
+});
 var AcknowledgmentSchema = z.object({
   nodeId: z.string(),
-  ruleId: z.string()
+  ruleId: z.string(),
+  intent: AcknowledgmentIntentSchema.optional(),
+  sceneWriteOutcome: AcknowledgmentSceneWriteOutcomeSchema.optional(),
+  codegenDirective: z.string().optional()
 });
 z.array(AcknowledgmentSchema);
 function normalizeNodeId(id) {
@@ -749,6 +868,7 @@ var RuleEngine = class {
   excludeNamePattern;
   excludeNodeTypes;
   acknowledgments;
+  scopeOverride;
   constructor(options = {}) {
     this.configs = options.configs ?? RULE_CONFIGS;
     this.enabledRuleIds = options.enabledRules ? new Set(options.enabledRules) : null;
@@ -761,6 +881,7 @@ var RuleEngine = class {
         (a) => `${normalizeNodeId(a.nodeId)}::${a.ruleId}`
       )
     );
+    this.scopeOverride = options.scope;
   }
   /**
    * Analyze a Figma file and return issues
@@ -777,6 +898,8 @@ var RuleEngine = class {
     }
     const maxDepth = calculateMaxDepth(rootNode);
     const nodeCount = countNodes(rootNode);
+    const scope = this.scopeOverride ?? detectAnalysisScope(rootNode);
+    const rootNodeType = rootNode.type;
     const issues = [];
     const failedRules = [];
     const enabledRules = this.getEnabledRules();
@@ -792,6 +915,8 @@ var RuleEngine = class {
       [],
       0,
       analysisState,
+      scope,
+      rootNodeType,
       void 0,
       void 0
     );
@@ -809,7 +934,8 @@ var RuleEngine = class {
       failedRules,
       maxDepth,
       nodeCount,
-      analyzedAt: (/* @__PURE__ */ new Date()).toISOString()
+      analyzedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      scope
     };
   }
   /**
@@ -827,7 +953,7 @@ var RuleEngine = class {
   /**
    * Recursively traverse the tree and run rules
    */
-  traverseAndCheck(node, file, rules, maxDepth, issues, failedRules, depth, path, ancestorTypes, componentDepth, analysisState, parent, siblings) {
+  traverseAndCheck(node, file, rules, maxDepth, issues, failedRules, depth, path, ancestorTypes, componentDepth, analysisState, scope, rootNodeType, parent, siblings) {
     const nodePath = [...path, node.name];
     const isComponentBoundary = node.type === "COMPONENT" || node.type === "COMPONENT_SET" || node.type === "INSTANCE";
     const currentComponentDepth = isComponentBoundary ? 0 : componentDepth;
@@ -846,7 +972,9 @@ var RuleEngine = class {
       path: nodePath,
       ancestorTypes,
       siblings,
-      analysisState
+      analysisState,
+      scope,
+      rootNodeType
     };
     for (const rule of rules) {
       const ruleId = rule.definition.id;
@@ -893,6 +1021,8 @@ var RuleEngine = class {
           childAncestorTypes,
           currentComponentDepth + 1,
           analysisState,
+          scope,
+          rootNodeType,
           node,
           node.children
         );
@@ -1202,6 +1332,10 @@ function buildResultJson(fileName, result, scores, options) {
     const suggestedName = issue.violation.suggestedName;
     return {
       ruleId: issue.violation.ruleId,
+      detection: "rule-based",
+      outputChannel: "score",
+      persistenceIntent: "transient",
+      purpose: getRulePurpose(issue.violation.ruleId),
       ...issue.violation.subType && { subType: issue.violation.subType },
       severity: issue.config.severity,
       nodeId: issue.violation.nodeId,
@@ -1224,6 +1358,7 @@ function buildResultJson(fileName, result, scores, options) {
     fileName,
     nodeCount: result.nodeCount,
     maxDepth: result.maxDepth,
+    scope: result.scope,
     issueCount: result.issues.length,
     acknowledgedCount: scores.summary.acknowledgedCount,
     isReadyForCodeGen: isReadyForCodeGen(scores.overall.grade),
@@ -2044,9 +2179,6 @@ function isContainerNode(node) {
 function hasAutoLayout(node) {
   return node.layoutMode !== void 0 && node.layoutMode !== "NONE";
 }
-function hasTextContent(node) {
-  return node.type === "TEXT" || (node.children?.some((c) => c.type === "TEXT") ?? false);
-}
 function hasOverlappingBounds(a, b) {
   const boxA = a.absoluteBoundingBox;
   const boxB = b.absoluteBoundingBox;
@@ -2187,12 +2319,6 @@ function isAbsolutePositionExempt(node) {
   if (isExcludedName(node.name)) return true;
   return false;
 }
-function isSizeConstraintExempt(node, context) {
-  if (node.maxWidth !== void 0) return true;
-  if (context.parent?.maxWidth !== void 0) return true;
-  if (context.depth <= 1) return true;
-  return false;
-}
 function isFixedSizeExempt(node) {
   if (isVisualOnlyNode(node)) return true;
   if (isExcludedName(node.name)) return true;
@@ -2259,21 +2385,21 @@ var fixedSizeMsg = {
   })
 };
 var missingSizeConstraintMsg = {
-  maxWidth: (name, currentWidth) => ({
-    message: `"${name}" uses FILL width (currently ${currentWidth}) without max-width`,
-    suggestion: `Add maxWidth to prevent stretching on large screens`
+  pageContainerUnbound: (name, currentWidth) => ({
+    message: `Container "${name}" uses FILL width (currently ${currentWidth}) and no ancestor defines a width bound`,
+    suggestion: `Decide whether this area should stretch with the screen, or set min/max-width here so the responsive behavior is explicit`
   }),
-  minWidth: (name, currentWidth) => ({
-    message: `"${name}" uses FILL width (currently ${currentWidth}) without min-width`,
-    suggestion: `Add minWidth to prevent collapsing on small screens`
+  pageInstanceFixed: (name, currentWidth) => ({
+    message: `Instance "${name}" has fixed width (${currentWidth}) inside an Auto Layout parent`,
+    suggestion: `Confirm whether this fixed width is intentional \u2014 if not, set the instance to FILL so it follows the parent's layout`
   }),
-  wrap: (name) => ({
-    message: `"${name}" is in a wrap container without min-width`,
-    suggestion: `Add minWidth to control when wrapping occurs`
+  componentFixedByDesign: (name, currentWidth) => ({
+    message: `Component "${name}" has fixed width (${currentWidth}) at its root`,
+    suggestion: `Confirm whether this component is intentionally non-responsive \u2014 otherwise switch root sizing to FILL or set min/max bounds`
   }),
-  grid: (name) => ({
-    message: `"${name}" is in a grid layout without size constraints`,
-    suggestion: `Add min/max-width for proper column sizing`
+  componentFixedByOverride: (name, currentWidth) => ({
+    message: `Instance "${name}" overrides root width to fixed (${currentWidth}); the original component may be FILL`,
+    suggestion: `Confirm whether the fixed-width override is intentional \u2014 if not, restore root sizing to inherit from the component definition`
   })
 };
 var nonLayoutContainerMsg = {
@@ -2565,44 +2691,97 @@ var missingSizeConstraintDef = {
   id: "missing-size-constraint",
   name: "Missing Size Constraint",
   category: "responsive-critical",
-  why: "Without min/max-width, AI has no bounds \u2014 generated code may collapse or stretch indefinitely",
-  impact: "Content becomes unreadable or invisible at extreme screen sizes",
-  fix: "Set min-width and/or max-width so AI can generate proper size constraints"
+  why: "Width sizing without explicit bounds (FIXED root or FILL chained to a bounded ancestor) is structurally indistinguishable from missing information \u2014 AI cannot tell whether the designer intended responsive stretching, a fixed cap, or simply forgot to set min/max",
+  impact: "Generated code either guesses hard-coded widths or omits responsive constraints; either way the runtime layout drifts from the design intent at viewports the designer never explicitly considered",
+  fix: "Answer the gotcha to declare intent (responsive vs. fixed-by-design vs. instance override), then encode the answer in Figma sizing \u2014 FILL/HUG with min/max for responsive bounds, FIXED only when intentionally non-responsive"
 };
-var missingSizeConstraintCheck = (node, context) => {
-  if (!isContainerNode(node) && !hasTextContent(node)) return null;
-  if (!context.parent || !hasAutoLayout(context.parent)) return null;
-  const nodePath = context.path.join(" > ");
-  if (context.parent.layoutWrap === "WRAP" && node.layoutSizingHorizontal === "FILL" && node.minWidth === void 0) {
-    return {
-      ruleId: missingSizeConstraintDef.id,
-      subType: "wrap",
-      nodeId: node.id,
-      nodePath,
-      ...missingSizeConstraintMsg.wrap(node.name)
-    };
-  }
-  if (context.parent.layoutMode === "GRID" && node.layoutSizingHorizontal === "FILL" && node.minWidth === void 0 && node.maxWidth === void 0) {
-    return {
-      ruleId: missingSizeConstraintDef.id,
-      subType: "grid",
-      nodeId: node.id,
-      nodePath,
-      ...missingSizeConstraintMsg.grid(node.name)
-    };
+var CHAIN_BOUND_KEY = "missing-size-constraint:chain-bound";
+function getChainBoundCache(context) {
+  return getAnalysisState(context, CHAIN_BOUND_KEY, () => /* @__PURE__ */ new Map());
+}
+function establishesOwnWidthBound(node) {
+  if (node.layoutSizingHorizontal === "FIXED") return true;
+  if (node.minWidth !== void 0 || node.maxWidth !== void 0) return true;
+  return false;
+}
+function recordChainBound(context, node) {
+  const cache = getChainBoundCache(context);
+  const cached = cache.get(node.id);
+  if (cached !== void 0) return cached;
+  const own = establishesOwnWidthBound(node);
+  const parent = context.parent;
+  const inherited = parent ? cache.get(parent.id) ?? false : false;
+  const result = own || inherited;
+  cache.set(node.id, result);
+  return result;
+}
+function parentChainBound(context) {
+  if (!context.parent) return false;
+  return getChainBoundCache(context).get(context.parent.id) ?? false;
+}
+var PAGE_CONTAINER_FRAME_TYPES = /* @__PURE__ */ new Set(["FRAME", "SECTION"]);
+function formatWidth(node) {
+  return node.absoluteBoundingBox ? `${node.absoluteBoundingBox.width}px` : "unknown";
+}
+function buildViolation(subType, node, context, msg) {
+  return {
+    ruleId: missingSizeConstraintDef.id,
+    subType,
+    nodeId: node.id,
+    nodePath: context.path.join(" > "),
+    ...msg
+  };
+}
+function checkComponentScopeRoot(node, context) {
+  if (context.depth !== 0) return null;
+  if (node.layoutSizingHorizontal !== "FIXED") return null;
+  const currentWidth = formatWidth(node);
+  if (context.rootNodeType === "INSTANCE") {
+    return buildViolation(
+      "component-fixed-by-override",
+      node,
+      context,
+      missingSizeConstraintMsg.componentFixedByOverride(node.name, currentWidth)
+    );
   }
-  if (node.layoutSizingHorizontal === "FILL") {
-    if (isSizeConstraintExempt(node, context)) return null;
-    const currentWidth = node.absoluteBoundingBox ? `${node.absoluteBoundingBox.width}px` : "unknown";
-    return {
-      ruleId: missingSizeConstraintDef.id,
-      subType: "max-width",
-      nodeId: node.id,
-      nodePath,
-      ...missingSizeConstraintMsg.maxWidth(node.name, currentWidth)
-    };
+  return buildViolation(
+    "component-fixed-by-design",
+    node,
+    context,
+    missingSizeConstraintMsg.componentFixedByDesign(node.name, currentWidth)
+  );
+}
+function checkPageInstanceFixed(node, context) {
+  if (node.type !== "INSTANCE") return null;
+  if (node.layoutSizingHorizontal !== "FIXED") return null;
+  if (!context.parent || !hasAutoLayout(context.parent)) return null;
+  const currentWidth = formatWidth(node);
+  return buildViolation(
+    "page-instance-fixed",
+    node,
+    context,
+    missingSizeConstraintMsg.pageInstanceFixed(node.name, currentWidth)
+  );
+}
+function checkPageContainerUnbound(node, context) {
+  if (!PAGE_CONTAINER_FRAME_TYPES.has(node.type)) return null;
+  if (node.layoutSizingHorizontal !== "FILL") return null;
+  if (parentChainBound(context)) return null;
+  const currentWidth = formatWidth(node);
+  return buildViolation(
+    "page-container-unbound",
+    node,
+    context,
+    missingSizeConstraintMsg.pageContainerUnbound(node.name, currentWidth)
+  );
+}
+var missingSizeConstraintCheck = (node, context) => {
+  recordChainBound(context, node);
+  if (context.ancestorTypes.includes("INSTANCE")) return null;
+  if (context.scope === "component") {
+    return checkComponentScopeRoot(node, context);
   }
-  return null;
+  return checkPageInstanceFixed(node, context) ?? checkPageContainerUnbound(node, context);
 };
 var missingSizeConstraint = defineRule({
   definition: missingSizeConstraintDef,
@@ -3957,7 +4136,16 @@ var CalibrationConfigSchema = z.object({
   maxConversionNodes: z.number().int().positive().default(20),
   samplingStrategy: SamplingStrategySchema.default("top-issues"),
   outputPath: z.string().default("logs/calibration/calibration-report.md"),
-  runDir: z.string().optional()
+  runDir: z.string().optional(),
+  /**
+   * #404: Explicit analysis scope for the calibration run. When omitted,
+   * the orchestrator (`scripts/calibrate.ts`) injects `"page"` as the
+   * policy default — `fixtures/done/*` are conceptually pages even though
+   * they are stored as `COMPONENT` variants ("Platform=Desktop" etc.) and
+   * would otherwise auto-detect as component scope. A `.scope` file in
+   * the fixture directory overrides the default per-fixture.
+   */
+  scope: AnalysisScopeSchema.optional()
 });
 var NodeIssueSummarySchema = z.object({
   nodeId: z.string(),
@@ -4966,7 +5154,10 @@ function buildRuleScoresMap() {
 async function runCalibrationAnalyze(config) {
   const parsed = CalibrationConfigSchema.parse(config);
   const { file, fileKey, nodeId } = await loadFile2(parsed.input, parsed.token);
-  const analyzeOptions = nodeId ? { targetNodeId: nodeId } : {};
+  const analyzeOptions = {
+    ...nodeId ? { targetNodeId: nodeId } : {},
+    ...parsed.scope ? { scope: parsed.scope } : {}
+  };
   const analysisResult = analyzeFile(file, analyzeOptions);
   const analysisOutput = runAnalysisAgent({ analysisResult });
   const ruleScores = {
@@ -5148,6 +5339,6 @@ var ActivityLogger = class {
   }
 };
 
-export { ALL_STRIP_TYPES, ActivityLogger, AnalysisFileSchema, AnalysisNodeSchema, AnalysisNodeTypeSchema, AnnotationPropertySchema, CATEGORIES, CATEGORY_LABELS, CalibrationConfigSchema, CalibrationStatusSchema, CategorySchema, CategoryScoreSchema, ConfidenceSchema, ConversionRecordSchema, DEPTH_WEIGHT_CATEGORIES, DESIGN_TREE_INFO_TYPES, DifficultySchema, FigmaClient, FigmaClientError, FigmaFileLoadError, FigmaUrlInfoSchema, FigmaUrlParseError, GapAnalyzerOutputSchema, GapEntrySchema, GotchaSurveyQuestionSchema, GotchaSurveySchema, GridChildAlignSchema, GroupedSurveySchema, InstanceContextSchema, IssueSchema, LayoutAlignSchema, LayoutConstraintSchema, LayoutModeSchema, LayoutPositioningSchema, LayoutWrapSchema, McpAnalyzeResponseSchema, MismatchCaseSchema, MismatchTypeSchema, NewRuleProposalSchema, NodeIssueSummarySchema, OverflowDirectionSchema, RULE_ANNOTATION_PROPERTIES, RULE_CONFIGS, RULE_ID_CATEGORY, ReportMetadataSchema, ReportSchema, RuleApplyStrategySchema, RuleConfigSchema, RuleDefinitionSchema, RuleEngine, RuleImpactAssessmentSchema, RuleRelatedStruggleSchema, SEVERITY_LABELS, SEVERITY_WEIGHT, SamplingStrategySchema, ScoreAdjustmentSchema, SeveritySchema, StripDeltaResultSchema, StripDeltasArraySchema, StripTypeEnum, SurveyQuestionBatchSchema, SurveyQuestionGroupSchema, UncoveredStruggleSchema, UncoveredStrugglesInputSchema, version as VERSION, VisualCompareCliOptionsSchema, absolutePositionInAutoLayout, analyzeFile, buildFigmaDeepLink, buildResultJson, calculateScores, collectComponentIds, collectInteractionDestinationIds, createRuleEngine, deepNesting, defineRule, detachedInstance, extractRuleScores, fixedSizeInAutoLayout, formatScoreSummary, generateCalibrationReport, generateDesignTree, generateDesignTreeWithStats, getAnalysisState, getAnnotationProperties, getCategoryLabel, getConfigsWithPreset, getRuleOption, getSeverityLabel, gradeToClassName, inconsistentNamingConvention, irregularSpacing, isInstanceChildNodeId, isReadyForCodeGen, loadFigmaFileFromJson, missingComponent, missingInteractionState, missingPrototype, missingSizeConstraint, noAutoLayout, nonLayoutContainer, nonSemanticName, nonStandardNaming, parseFigmaJson, parseFigmaUrl, parseInstanceChildNodeId, rawValue, resolveComponentDefinitions, resolveGotchaApplyTarget, resolveInteractionDestinations, ruleRegistry, runAnalysisAgent, runCalibrationAnalyze, runCalibrationEvaluate, runEvaluationAgent, runTuningAgent, stripDeltaToDifficulty, stripDesignTree, supportsDepthWeight, toCommentableNodeId, tokenDeltaToDifficulty, transformComponentMasterNodes, transformFigmaResponse, transformFileNodesResponse, variantStructureMismatch };
+export { ALL_STRIP_TYPES, ActivityLogger, AnalysisFileSchema, AnalysisNodeSchema, AnalysisNodeTypeSchema, AnalysisScopeSchema, AnnotationPropertySchema, CATEGORIES, CATEGORY_LABELS, CalibrationConfigSchema, CalibrationStatusSchema, CategorySchema, CategoryScoreSchema, ConfidenceSchema, ConversionRecordSchema, DEPTH_WEIGHT_CATEGORIES, DESIGN_TREE_INFO_TYPES, DetectionSchema, DifficultySchema, FigmaClient, FigmaClientError, FigmaFileLoadError, FigmaUrlInfoSchema, FigmaUrlParseError, GapAnalyzerOutputSchema, GapEntrySchema, GotchaDetectionSchema, GotchaOutputChannelSchema, GotchaPersistenceIntentSchema, GotchaSurveyQuestionSchema, GotchaSurveySchema, GridChildAlignSchema, GroupedSurveySchema, InstanceContextSchema, IssueSchema, LayoutAlignSchema, LayoutConstraintSchema, LayoutModeSchema, LayoutPositioningSchema, LayoutWrapSchema, McpAnalyzeResponseSchema, MismatchCaseSchema, MismatchTypeSchema, NewRuleProposalSchema, NodeIssueSummarySchema, OutputChannelSchema, OverflowDirectionSchema, PersistenceIntentSchema, RULE_ANNOTATION_PROPERTIES, RULE_CONFIGS, RULE_ID_CATEGORY, RULE_PURPOSE, ReportMetadataSchema, ReportSchema, RuleApplyStrategySchema, RuleConfigSchema, RuleDefinitionSchema, RuleEngine, RuleImpactAssessmentSchema, RulePurposeSchema, RuleRelatedStruggleSchema, SEVERITY_LABELS, SEVERITY_WEIGHT, SamplingStrategySchema, ScoreAdjustmentSchema, SeveritySchema, StripDeltaResultSchema, StripDeltasArraySchema, StripTypeEnum, SurveyQuestionBatchSchema, SurveyQuestionGroupSchema, UncoveredStruggleSchema, UncoveredStrugglesInputSchema, version as VERSION, VisualCompareCliOptionsSchema, absolutePositionInAutoLayout, analyzeFile, buildFigmaDeepLink, buildResultJson, calculateScores, collectComponentIds, collectInteractionDestinationIds, createRuleEngine, deepNesting, defineRule, detachedInstance, detectAnalysisScope, extractRuleScores, fixedSizeInAutoLayout, formatScoreSummary, generateCalibrationReport, generateDesignTree, generateDesignTreeWithStats, getAnalysisState, getAnnotationProperties, getCategoryLabel, getConfigsWithPreset, getRuleOption, getRulePurpose, getSeverityLabel, gradeToClassName, inconsistentNamingConvention, irregularSpacing, isInstanceChildNodeId, isReadyForCodeGen, loadFigmaFileFromJson, missingComponent, missingInteractionState, missingPrototype, missingSizeConstraint, noAutoLayout, nonLayoutContainer, nonSemanticName, nonStandardNaming, parseFigmaJson, parseFigmaUrl, parseInstanceChildNodeId, rawValue, resolveComponentDefinitions, resolveGotchaApplyTarget, resolveInteractionDestinations, ruleRegistry, runAnalysisAgent, runCalibrationAnalyze, runCalibrationEvaluate, runEvaluationAgent, runTuningAgent, stripDeltaToDifficulty, stripDesignTree, supportsDepthWeight, toCommentableNodeId, tokenDeltaToDifficulty, transformComponentMasterNodes, transformFigmaResponse, transformFileNodesResponse, variantStructureMismatch };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map