@directededges/specs-from-figma 0.21.0 → 0.22.0

package/dist/Component/Elements/Primitives/InstanceElement.d.ts

@@ -0,0 +1,24 @@
+import { BaseElement } from "../BaseElement.js";
+import { ResolvedConfig } from '@directededges/specs-schema';
+import { type ProcessingContext } from '../../../Runtime/Context/interfaces.js';
+export declare class InstanceElement extends BaseElement {
+    resolvedInstanceName?: string;
+    constructor(node: InstanceNode, config: ResolvedConfig);
+    protected extendedEvaluate(): Promise<void>;
+    /**
+     * Resolve the main component name for an instance node.
+     * Returns the component set name if the main component belongs to a set,
+     * otherwise returns the component name directly.
+     */
+    static resolveMainComponentName(node: InstanceNode): Promise<string>;
+    /**
+     * Determine the main component reference asynchronously.
+     * Uses cached resolvedInstanceName from detect() if available.
+     */
+    private instanceName;
+    /**
+     * Post-process for InstanceElement.
+     * With unified bindings, instanceOf already contains the binding info.
+     */
+    protected extendedPostProcess(context?: ProcessingContext): Promise<void>;
+}

package/dist/Component/Elements/Primitives/LineElement.d.ts

@@ -0,0 +1,8 @@
+import { BaseElement } from "../BaseElement.js";
+import { ResolvedConfig } from '@directededges/specs-schema';
+import type { ProcessingContext } from '../../../Runtime/Context/interfaces.js';
+export declare class LineElement extends BaseElement {
+    constructor(node: LineNode, config: ResolvedConfig);
+    protected extendedEvaluate(): Promise<void>;
+    protected extendedPostProcess(_context?: ProcessingContext): Promise<void>;
+}

package/dist/Component/Elements/Primitives/PolygonElement.d.ts

@@ -0,0 +1,8 @@
+import { BaseElement } from "../BaseElement.js";
+import { ResolvedConfig } from '@directededges/specs-schema';
+import type { ProcessingContext } from '../../../Runtime/Context/interfaces.js';
+export declare class PolygonElement extends BaseElement {
+    constructor(node: PolygonNode, config: ResolvedConfig);
+    protected extendedEvaluate(): Promise<void>;
+    protected extendedPostProcess(_context?: ProcessingContext): Promise<void>;
+}

package/dist/Component/Elements/Primitives/RectangleElement.d.ts

@@ -0,0 +1,8 @@
+import { BaseElement } from "../BaseElement.js";
+import { ResolvedConfig } from '@directededges/specs-schema';
+import type { ProcessingContext } from '../../../Runtime/Context/interfaces.js';
+export declare class RectangleElement extends BaseElement {
+    constructor(node: RectangleNode, config: ResolvedConfig);
+    protected extendedEvaluate(): Promise<void>;
+    protected extendedPostProcess(_context?: ProcessingContext): Promise<void>;
+}

package/dist/Component/Elements/Primitives/SlotElement.d.ts

@@ -0,0 +1,8 @@
+import { BaseElement } from "../BaseElement.js";
+import { ResolvedConfig } from '@directededges/specs-schema';
+import type { ProcessingContext } from '../../../Runtime/Context/interfaces.js';
+export declare class SlotElement extends BaseElement {
+    constructor(node: SlotNode, config: ResolvedConfig);
+    protected extendedEvaluate(): Promise<void>;
+    protected extendedPostProcess(_context?: ProcessingContext): Promise<void>;
+}

package/dist/Component/Elements/Primitives/StarElement.d.ts

@@ -0,0 +1,8 @@
+import { BaseElement } from "../BaseElement.js";
+import { ResolvedConfig } from '@directededges/specs-schema';
+import type { ProcessingContext } from '../../../Runtime/Context/interfaces.js';
+export declare class StarElement extends BaseElement {
+    constructor(node: StarNode, config: ResolvedConfig);
+    protected extendedEvaluate(): Promise<void>;
+    protected extendedPostProcess(_context?: ProcessingContext): Promise<void>;
+}

package/dist/Component/Elements/Primitives/TextElement.d.ts

@@ -0,0 +1,8 @@
+import { BaseElement } from "../BaseElement.js";
+import { ResolvedConfig } from '@directededges/specs-schema';
+import type { ProcessingContext } from '../../../Runtime/Context/interfaces.js';
+export declare class TextElement extends BaseElement {
+    constructor(node: TextNode, config: ResolvedConfig);
+    protected extendedEvaluate(): Promise<void>;
+    protected extendedPostProcess(_context?: ProcessingContext): Promise<void>;
+}

package/dist/Component/Elements/Primitives/VectorElement.d.ts

@@ -0,0 +1,8 @@
+import { BaseElement } from "../BaseElement.js";
+import { ResolvedConfig } from '@directededges/specs-schema';
+import type { ProcessingContext } from '../../../Runtime/Context/interfaces.js';
+export declare class VectorElement extends BaseElement {
+    constructor(node: VectorNode, config: ResolvedConfig);
+    protected extendedEvaluate(): Promise<void>;
+    protected extendedPostProcess(_context?: ProcessingContext): Promise<void>;
+}

package/dist/Component/Elements/index.d.ts

@@ -0,0 +1,12 @@
+export { BaseElement } from "./BaseElement.js";
+export { ElementFactory } from "./ElementFactory.js";
+export { ComponentElement } from "./Primitives/ComponentElement.js";
+export { FrameElement } from "./Primitives/FrameElement.js";
+export { InstanceElement } from "./Primitives/InstanceElement.js";
+export { TextElement } from "./Primitives/TextElement.js";
+export { VectorElement } from "./Primitives/VectorElement.js";
+export { LineElement } from "./Primitives/LineElement.js";
+export { StarElement } from "./Primitives/StarElement.js";
+export { PolygonElement } from "./Primitives/PolygonElement.js";
+export { RectangleElement } from "./Primitives/RectangleElement.js";
+export { EllipseElement } from "./Primitives/EllipseElement.js";

package/dist/Component/Gradient/Gradient.d.ts

@@ -0,0 +1,73 @@
+import type { GradientValue, GradientStop, ResolvedConfig } from '@directededges/specs-schema';
+import { type ProcessingContext } from '../../Runtime/Context/interfaces.js';
+/**
+ * Type guard for gradient paints
+ */
+type GradientPaint = Extract<Paint, {
+    type: 'GRADIENT_LINEAR' | 'GRADIENT_RADIAL' | 'GRADIENT_ANGULAR' | 'GRADIENT_DIAMOND';
+}>;
+/**
+ * Gradient — first-class component for Figma gradient fills
+ *
+ * Instance-based class (peer to Shadow/Blur/Effects) that wraps a GradientValue.
+ * Provides lifecycle methods (difference, clone, data) and handles conversion
+ * from Figma gradient paints to structured gradient values.
+ *
+ * Usage:
+ *   const gradient = new Gradient();
+ *   gradient.evaluate(paint);
+ */
+export declare class Gradient {
+    private _value;
+    constructor(value?: GradientValue);
+    get value(): GradientValue;
+    get type(): 'LINEAR' | 'RADIAL' | 'ANGULAR';
+    get stops(): GradientStop[];
+    /**
+     * Returns true if this Gradient differs from base.
+     * Compares gradient type, geometry (angle/center), and all stops.
+     */
+    difference(base: Gradient): boolean;
+    /**
+     * Serialize this Gradient for output, respecting config.format.tokens.
+     * FigmaVariableReference stop colors are converted per config profile.
+     * Color instances serialize via .data(config.format.color).
+     */
+    data(config: ResolvedConfig): GradientValue;
+    /**
+     * Create a deep clone of this Gradient instance.
+     */
+    clone(): Gradient;
+    /**
+     * Populate gradient value from a Figma gradient paint.
+     * Returns true if evaluation succeeded, false if paint is unsupported/invalid.
+     *
+     * @param paint - Figma gradient paint (GRADIENT_LINEAR, GRADIENT_RADIAL, GRADIENT_ANGULAR)
+     */
+    evaluate(paint: GradientPaint, context?: ProcessingContext): boolean;
+    /**
+     * Static factory: construct and evaluate in one call.
+     * Returns Gradient instance or null if evaluation failed.
+     *
+     * @param paint - Figma gradient paint
+     */
+    static fromPaint(paint: GradientPaint, context?: ProcessingContext): Gradient | null;
+    /**
+     * Check if a paint is a gradient type (LINEAR, RADIAL, ANGULAR, or DIAMOND)
+     */
+    static isGradientPaint(paint: Paint | undefined): boolean;
+    /**
+     * Extract CSS-equivalent angle from Figma linear gradient transform
+     */
+    private static evaluateAngle;
+    /**
+     * Extract center position from Figma radial/angular gradient transform
+     */
+    private static evaluateCenter;
+    /**
+     * Convert Figma gradient stops to GradientStop array.
+     * Returns null if < 2 stops (Figma requires at least 2).
+     */
+    private static evaluateStops;
+}
+export {};

package/dist/Component/Gradient/GradientProcessor.d.ts

@@ -0,0 +1,18 @@
+import { Gradient } from './Gradient.js';
+import type { ProcessingContext } from '../../Runtime/Context/interfaces.js';
+/**
+ * GradientProcessor — post-processing logic for Gradient instances
+ *
+ * Handles variable name resolution for gradient stop colors.
+ * Peer to EffectsProcessor.
+ */
+export declare class GradientProcessor {
+    /**
+     * Performs post-processing on a Gradient instance.
+     * Resolves variable names for any FigmaVariableReference stop colors.
+     *
+     * @param gradient The Gradient instance to process
+     * @param context Optional processing context with foundations loader
+     */
+    static postProcess(gradient: Gradient | null, context?: ProcessingContext): Promise<void>;
+}

package/dist/Component/Gradient/index.d.ts

@@ -0,0 +1,2 @@
+export { Gradient } from './Gradient.js';
+export { GradientProcessor } from './GradientProcessor.js';

package/dist/Component/InstanceExamples/InstanceExample.d.ts

@@ -0,0 +1,35 @@
+import type { InstanceExample as AnovaInstanceExample, ResolvedConfig, SlotContentRef } from '@directededges/specs-schema';
+import type { ProcessingContext } from '../../Runtime/Context/interfaces.js';
+/**
+ * Per-example builder (ADR-048 / ADR-050). Maps one detected INSTANCE node into an
+ * `InstanceExample` — `{ title, propConfigurations? }`.
+ *
+ * Scalar prop configuration (TEXT/BOOLEAN/VARIANT/INSTANCE_SWAP coercion, key
+ * formatting, instance-swap name resolution, and slot-constraint folding) is
+ * delegated to `PropConfigurations` — the same machinery instance elements use —
+ * so an example serializes a configured instance identically to the rest of the
+ * spec. Slot props are supplied as pre-resolved `SlotContentRef`s by the owning
+ * `InstanceExamples` collaborator (which performs slot detection and owns the
+ * shared registry); the example holds no slot content of its own.
+ *
+ * `PropBinding` is never emitted — an instance example is a documented configuration,
+ * not a live data binding (ADR-048).
+ *
+ * Construction mirrors sibling per-item builders (`Subcomponent`, `PropConfigurations`):
+ * `(node, config)`; per-call context arrives via `resolve()` / `data()`.
+ */
+export declare class InstanceExample {
+    private _node;
+    private _props;
+    constructor(node: InstanceNode, config: ResolvedConfig);
+    /** The original node name, used as the human-readable title. */
+    get title(): string;
+    /** Resolve scalar prop configurations (incl. INSTANCE_SWAP names). Run before `data()`. */
+    resolve(context?: ProcessingContext): Promise<void>;
+    /**
+     * Build the `InstanceExample`. `slotRefs` are the example's resolved slot-prop
+     * references (keyed by slot prop key), supplied by `InstanceExamples`.
+     * `propConfigurations` is omitted when the example exposes no configurable props.
+     */
+    data(slotRefs: Record<string, SlotContentRef>): AnovaInstanceExample;
+}

package/dist/Component/InstanceExamples/InstanceExamples.d.ts

@@ -0,0 +1,49 @@
+import type { InstanceExamples as AnovaInstanceExamples, ResolvedConfig } from '@directededges/specs-schema';
+import type { SlotRegistry } from '../SlotContent/SlotRegistry.js';
+import { type ProcessingContext } from '../../Runtime/Context/interfaces.js';
+/**
+ * Top-level collaborator for instance examples (ADR-048 + ADR-050) — sibling to
+ * Subcomponents and SlotContent. Reads `processing.instanceExamples`, gathers
+ * candidate nodes by scope (PAGE | FILE), applies match/exclude/parentNames
+ * filtering, and builds keyed `InstanceExample` entries.
+ *
+ * Detection mirrors `processing.subcomponents`. Output gating
+ * (`include.instanceExamples`) is applied by the caller in `Component.data()`.
+ */
+export declare class InstanceExamples {
+    /** example key → builder + its resolved slot-prop refs */
+    private _items;
+    private config;
+    constructor(config: ResolvedConfig);
+    /**
+     * Compile an example name pattern (with `{C}` and `*`) into a RegExp and test it.
+     * `{C}` expands to the (escaped) component name; `*` becomes `.*`.
+     * Independent of `Subcomponents.matchesPatterns` (which uses `{S}` capture semantics).
+     */
+    static matchesExamplePattern(name: string, patterns: string[], componentName: string): boolean;
+    /**
+     * Detect instance examples for the given host component and contribute their
+     * slot fills to the shared registry.
+     *
+     * Candidates are INSTANCE nodes only (FRAME nodes are rejected), found via a
+     * boundary-respecting walk (the runtime's getPageSiblings / getAllPagesNodes,
+     * which stop at COMPONENT/COMPONENT_SET/INSTANCE). Applies for both PAGE and
+     * FILE scope. No-op when `processing.instanceExamples` is absent.
+     *
+     * `stampReferences` (= include.instanceExamples) controls whether slot refs are
+     * stamped and registry entries marked referenced. Detection always runs so the
+     * shared registry is populated regardless of the include flag.
+     */
+    evaluate(componentName: string, basePath: string, registry: SlotRegistry, stampReferences: boolean, acceptableComponentIds: Set<string>, context?: ProcessingContext, rootNodeId?: string): Promise<void>;
+    /**
+     * Detect filled slots inside an example instance (recursively, incl. slot ›
+     * instance › slot nesting) via the shared SlotDetector, contribute every level
+     * to the shared registry (deduped, example-key-prefixed), and — when stamping —
+     * mark referenced and wire nested refs. Returns the top-level slot-prop refs.
+     */
+    private _contributeSlots;
+    /** Serialize to the keyed `InstanceExamples` record, sorted by key for determinism. */
+    data(): AnovaInstanceExamples;
+    get size(): number;
+    get isEmpty(): boolean;
+}

package/dist/Component/Layout/Layout.d.ts

@@ -0,0 +1,26 @@
+import { ResolvedConfig } from '@directededges/specs-schema';
+import type { LayoutTree, LayoutSerializedNode } from './types.js';
+/**
+ * Layout: builds and compares per-variant element hierarchy as a nested tree.
+ * Primary construction is via constructor with a provided node list.
+ */
+export declare class Layout {
+    private _tree;
+    private _config;
+    constructor(config: ResolvedConfig, tree: LayoutTree);
+    /**
+     * Get the internal layout tree.
+     */
+    get tree(): LayoutTree;
+    /**
+     * Compare the current layout tree against a baseline.
+     * Follows BaseElement.compare pattern: returns undefined if equal,
+     * otherwise returns a new Layout instance with the current tree when different.
+     */
+    compare(baseline: Layout | undefined): Layout | undefined;
+    /**
+     * Return nested array representation suitable for serialization.
+     */
+    data(): LayoutSerializedNode[];
+    private serialize;
+}

package/dist/Component/Layout/types.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Nested layout tree node used internally.
+ */
+export interface LayoutNode {
+    name: string;
+    children: LayoutNode[];
+}
+/**
+ * Rooted layout tree container.
+ */
+export interface LayoutTree {
+    root: LayoutNode;
+}
+/**
+ * Serialized tree representation returned by data().
+ * Format: Array containing the root node object.
+ * Leaf nodes are strings, parent nodes are { [nodeName]: children[] }.
+ * Example:
+ * [
+ *   {
+ *     "root": [
+ *       {
+ *         "labelContainer": [
+ *           "requiredIndicator",
+ *           "label",
+ *           "secondaryDescription"
+ *         ]
+ *       },
+ *       {
+ *         "control": [
+ *           "value",
+ *           "placeholder",
+ *           "startIcon"
+ *         ]
+ *       }
+ *     ]
+ *   }
+ * ]
+ */
+export type LayoutSerializedNode = string | {
+    [nodeName: string]: LayoutSerializedNode[];
+};
+export type LayoutData = LayoutSerializedNode[];
+/**
+ * Whole-tree comparison result.
+ */
+export interface LayoutComparison {
+    equal: boolean;
+    added: string[];
+    removed: string[];
+    moved: Array<{
+        name: string;
+        fromPath: string[];
+        toPath: string[];
+    }>;
+    orderChanges: Array<{
+        parent: string;
+        previousOrder: string[];
+        currentOrder: string[];
+    }>;
+}

package/dist/Component/Metadata/Metadata.d.ts

@@ -0,0 +1,13 @@
+import { Metadata as AnovaMetadata } from '@directededges/specs-schema';
+import { SpecableNode } from "../Nodes/types";
+import { ResolvedConfig } from '@directededges/specs-schema';
+import type { ProcessingContext } from "../../Runtime/Context/interfaces";
+export declare class Metadata {
+    /**
+     * Find the page ID by traversing up the parent chain
+     * Handles both Plugin and REST contexts
+     * Note: Plugin API uses 'PAGE' type, REST API uses 'CANVAS' type for pages
+     */
+    private static findPageId;
+    static create(node: SpecableNode, config: ResolvedConfig, context?: ProcessingContext): AnovaMetadata;
+}

package/dist/Component/Metadata/constants.d.ts

@@ -0,0 +1,8 @@
+export declare const METADATA: {
+    PLUGIN_VERSION: string;
+    PLUGIN_NAME: string;
+    PLUGIN_URL: string;
+    SCHEMA_VERSION: string;
+    SCHEMA_URL: string;
+    SCHEMA_LATEST_URL: string;
+};

package/dist/Component/Nodes/types.d.ts

@@ -0,0 +1,4 @@
+export type SpecableNode = ComponentNode | ComponentSetNode | FrameNode;
+export type FigmaElementNode = ComponentNode | FrameNode | InstanceNode | TextNode | VectorNode | LineNode | StarNode | PolygonNode | RectangleNode | EllipseNode | SlotNode;
+export type FigmaContainerNode = ComponentNode | FrameNode | InstanceNode;
+export type FigmaCorneredNode = ComponentNode | InstanceNode | FrameNode | RectangleNode;

package/dist/Component/PropConfigurations/PropConfiguration.d.ts

@@ -0,0 +1,15 @@
+import type { PropConfigurationValue } from './PropConfigurations';
+/**
+ * PropConfiguration
+ *
+ * Represents a single component property configuration value.
+ * Wrapper class to enable type-safe iteration and Output rendering.
+ *
+ * Pattern: Singular wrapper (like Style.ts) for individual entries
+ * Used by: PropConfigurations.entries() → Attribute → Value
+ */
+export declare class PropConfiguration {
+    readonly key: string;
+    readonly value: PropConfigurationValue;
+    constructor(key: string, value: PropConfigurationValue);
+}

package/dist/Component/PropConfigurations/PropConfigurations.d.ts

@@ -0,0 +1,55 @@
+import type { PropConfigurations as AnovaPropConfigurations } from '@directededges/specs-schema';
+import { ResolvedConfig } from '@directededges/specs-schema';
+import type { ProcessingContext } from '../../Runtime/Context/interfaces.js';
+import { PropConfiguration } from './PropConfiguration.js';
+export type PropConfigurationValue = string | number | boolean;
+export declare class PropConfigurations {
+    private _items;
+    private _types;
+    private _node;
+    private config;
+    constructor(node: InstanceNode, config: ResolvedConfig);
+    /**
+     * Evaluate component properties. Stores raw values (including component IDs
+     * for INSTANCE_SWAP) so that merge/compare operate on cheap identity checks.
+     * Name resolution for INSTANCE_SWAP happens lazily at data() time.
+     */
+    evaluate(): void;
+    /**
+     * Merge another PropConfigurations instance onto this one.
+     * Layer properties take precedence over base properties.
+     * Performs property-level merge: base properties are preserved unless layer overrides them.
+     *
+     * @param layer - The PropConfigurations to merge onto this one
+     * @returns A new PropConfigurations instance with merged values
+     */
+    merge(layer: PropConfigurations): PropConfigurations;
+    /**
+     * Compare this PropConfigurations against a baseline to identify differences.
+     * Returns a new PropConfigurations instance containing only differences.
+     *
+     * @param baseline - The PropConfigurations to compare against
+     * @returns A new PropConfigurations instance with differences, or empty if no differences
+     */
+    compare(baseline: PropConfigurations): PropConfigurations;
+    /**
+     * Resolve INSTANCE_SWAP component IDs to human-readable names.
+     * Called during postProcess (after merge/compare) so that evaluate/compare
+     * operate on cheap raw IDs and name lookup only happens for the final output set.
+     * Writes resolved names back into _items so that entries()/get() return
+     * resolved values without dual-state — before postProcess they hold raw IDs,
+     * after postProcess they hold resolved names.
+     */
+    postProcess(context?: ProcessingContext): Promise<void>;
+    data(): AnovaPropConfigurations | undefined;
+    get(name: string): PropConfigurationValue | undefined;
+    set(name: string, value: PropConfigurationValue | PropConfiguration): void;
+    [Symbol.iterator](): IterableIterator<[string, PropConfiguration]>;
+    entries(): IterableIterator<[string, PropConfiguration]>;
+    values(): IterableIterator<PropConfigurationValue>;
+    keys(): IterableIterator<string>;
+    get size(): number;
+    isEmpty(): boolean;
+    copy(source: PropConfigurations, keys?: Set<string> | string[]): void;
+    clone(): PropConfigurations;
+}

package/dist/Component/Props/CodeOnlyProps/BooleanCodeOnlyProp.d.ts

@@ -0,0 +1,11 @@
+import type { BooleanProp } from '@directededges/specs-schema';
+import type { FigmaElementNode } from '../../Nodes/types.js';
+/**
+ * Extracts BooleanProp from a node whose visibility is bound to a BOOLEAN prop.
+ */
+export declare class BooleanCodeOnlyProp {
+    /** A node is extractable if it has a 'visible' binding. */
+    static canExtract(node: FigmaElementNode): boolean;
+    /** Extract a BooleanProp. The current visible state becomes the default. */
+    static extract(node: FigmaElementNode): BooleanProp;
+}

package/dist/Component/Props/CodeOnlyProps/CodeOnlyProps.d.ts

@@ -0,0 +1,36 @@
+import type { AnyProp, ResolvedConfig, Props as AnovaProps } from '@directededges/specs-schema';
+import type { FigmaElementNode } from '../../Nodes/types.js';
+/**
+ * Orchestrator for code-only prop extraction.
+ * Routes descendant nodes to specialized extractors (Text, Boolean, Instance)
+ * and merges results into the native props map.
+ */
+export declare class CodeOnlyProps {
+    /**
+     * Full code-only props pipeline: extract, merge with native props,
+     * and post-process slot constraints.
+     *
+     * Keys are stored raw (unformatted). Props.data() handles formatting and sorting.
+     * Mutates nativeProps in place.
+     */
+    static process(container: FigmaElementNode, nativeProps: AnovaProps, processing: ResolvedConfig['processing']): Promise<void>;
+    /**
+     * Returns the set of raw (unformatted) prop names that will be extracted from the container.
+     * Used by Props.process() to pre-exclude these from native prop extraction.
+     */
+    static getCodeOnlyPropNames(container: FigmaElementNode): Set<string>;
+    /**
+     * Extract code-only props from a container node by routing each descendant
+     * to the appropriate specialized extractor.
+     */
+    static extract(container: FigmaElementNode, existingProps: Record<string, AnyProp>, processing: ResolvedConfig['processing']): Promise<Map<string, AnyProp>>;
+    /**
+     * Extract the component property name from a node's componentPropertyReferences.
+     * Ref values are formatted as "PropName#nodeId" — returns the part before '#'.
+     */
+    private static getPropNameFromRefs;
+    /**
+     * Recursively collect all descendant nodes from a container.
+     */
+    private static descendants;
+}

package/dist/Component/Props/CodeOnlyProps/InstanceCodeOnlyProp.d.ts

@@ -0,0 +1,19 @@
+import type { BooleanProp, EnumProp } from '@directededges/specs-schema';
+import type { FigmaElementNode } from '../../Nodes/types.js';
+/**
+ * Extracts BooleanProp or EnumProp from an INSTANCE node used as a code-only prop picker.
+ * The instance's component must have exactly one VARIANT property in componentPropertyDefinitions.
+ */
+export declare class InstanceCodeOnlyProp {
+    /** An INSTANCE node is extractable if it has type 'INSTANCE'. */
+    static canExtract(node: FigmaElementNode): boolean;
+    /**
+     * Extract a BooleanProp or EnumProp from the instance's variant definition.
+     * Returns null if the instance does not meet the single-VARIANT contract.
+     * Returns `propName` derived from the VARIANT key (not the node name).
+     */
+    static extract(node: FigmaElementNode): Promise<{
+        prop: BooleanProp | EnumProp;
+        propName: string;
+    } | null>;
+}

package/dist/Component/Props/CodeOnlyProps/TextCodeOnlyProp.d.ts

@@ -0,0 +1,18 @@
+import type { StringProp, NumberProp } from '@directededges/specs-schema';
+import type { FigmaElementNode } from '../../Nodes/types.js';
+/**
+ * Extracts StringProp or NumberProp from a TEXT layer bound to a characters prop.
+ */
+export declare class TextCodeOnlyProp {
+    /** A TEXT node is extractable if it has a 'characters' binding. */
+    static canExtract(node: FigmaElementNode): boolean;
+    /**
+     * Extract a StringProp or NumberProp from a text layer.
+     * When `inferNumber` is true and the text content passes the numeric guard,
+     * emits NumberProp instead of StringProp (ADR 029).
+     */
+    static extract(node: FigmaElementNode, inferNumber?: boolean): StringProp | NumberProp;
+    private static buildStringProp;
+    private static buildNumberProp;
+    private static extensions;
+}

package/dist/Component/Props/CodeOnlyProps/index.d.ts

@@ -0,0 +1,4 @@
+export { CodeOnlyProps } from './CodeOnlyProps.js';
+export { TextCodeOnlyProp } from './TextCodeOnlyProp.js';
+export { BooleanCodeOnlyProp } from './BooleanCodeOnlyProp.js';
+export { InstanceCodeOnlyProp } from './InstanceCodeOnlyProp.js';

package/dist/Component/Props/PropBinding.d.ts

@@ -0,0 +1,69 @@
+import { ResolvedConfig, PropBinding as AnovaPropBinding } from '@directededges/specs-schema';
+import { RawStyle } from '../Styles/References/FigmaVariableReference.js';
+/**
+ * PropBinding - represents a property that can optionally be bound to a component property.
+ *
+ * Unified binding class used for:
+ * - Element properties: `instanceOf`, `text` (value: string)
+ * - Style properties: `visible` (value: RawStyle)
+ *
+ * Always stores the raw value; optionally stores a ref for bound properties.
+ * Emits `{ $binding: "#/props/{property name}" }` when bound.
+ */
+export declare class PropBinding {
+    readonly value: string | RawStyle;
+    readonly ref: string | null;
+    constructor(value: string | RawStyle, ref?: string);
+    /**
+     * Check if this property is bound to a component property.
+     */
+    isBound(): boolean;
+    /**
+     * Get the prop name from the $ref (without the #/props/ prefix).
+     * Returns null if not bound.
+     */
+    propName(): string | null;
+    /**
+     * Get the raw value (for rendering/comparison purposes).
+     */
+    rawValue(): string | RawStyle;
+    /**
+     * Serialize this PropBinding for output.
+     * Returns `{ $binding }` when bound, otherwise the raw value.
+     * When `formatValue` is true, applies key formatting to unbound string values.
+     *
+     * @param keyFormat - Key formatting config
+     * @param formatValue - Whether to apply Utilities.formatKey to unbound string values
+     */
+    data(keyFormat: ResolvedConfig['format']['keys'], formatValue?: boolean): string | RawStyle | AnovaPropBinding;
+    static formatPropBinding(ref: string, keyFormat: ResolvedConfig['format']['keys']): AnovaPropBinding;
+    /**
+     * Compare this property against a baseline to identify differences.
+     * Returns this property if different, null if same.
+     */
+    compare(baseline: PropBinding | null): PropBinding | null;
+    /**
+     * Check if this binding differs from another (used by Style.difference).
+     */
+    difference(other: PropBinding): boolean;
+    /**
+     * Merge another property onto this one.
+     * Layer wins if non-null.
+     */
+    merge(layer: PropBinding | null): PropBinding;
+    /**
+     * Create a clone of this property.
+     */
+    clone(): PropBinding;
+    /**
+     * Create a PropBinding, optionally bound if refString is provided.
+     * Handles parsing the propName from Figma's ref format (e.g., "propName#nodeId").
+     * @param value The raw value (string for Element props, RawStyle for Style props)
+     * @param refString The componentPropertyReferences value (e.g., "propName#123:456"), or undefined if not bound
+     */
+    static create(value: string | RawStyle, refString?: string): PropBinding;
+    /**
+     * Type guard to check if a value is a PropBinding.
+     */
+    static is(v: unknown): v is PropBinding;
+}