@directededges/specs-from-figma 0.22.0 → 0.24.0

package/dist/Component/Variants/Differencer.d.ts

@@ -1,47 +0,0 @@
-import { Variant } from './Variant.js';
-import { Elements } from '../Elements/Elements.js';
-import { BaseElement } from '../Elements/BaseElement.js';
-import type { ProcessingContext } from '../../Runtime/Context/interfaces.js';
-/**
- * Utility class for establishing element parity between variants during the difference operation.
- * Ensures that baseline and current variants have matching element sets before comparison.
- */
-export declare class Differencer {
-    constructor();
-    /**
-     * Ensures the baseline variant has all elements present in the current variant.
-     * For any element in the current variant missing from the baseline, adds a fallback
-     * element to the baseline to enable proper comparison.
-     *
-     * @param baseVariantFull - The baseline variant's full element collection to modify
-     * @param currentVariant - The current variant being differenced
-     * @param layeredMatches - Array of layeredMatches to search for fallback elements (DEFAULT is [0])
-     * @param context - Processing context for license-aware evaluation
-     * @returns Promise that resolves when all missing elements have been added
-     */
-    static establishBaselineParity(baseVariantFull: Elements, currentVariant: Variant, layeredMatches: Variant[], context?: ProcessingContext): Promise<void>;
-    /**
-     * Finds a fallback element for baseline parity by searching layeredMatches.
-     * Instead of traversing baseline chain, searches through all provided layeredMatches.
-     * If not found in any layeredMatch, adds to default variant (layeredMatches[0]).
-     *
-     * @param currentVariant - The current variant needing the fallback element
-     * @param elementName - The name of the element to find
-     * @param layeredMatches - Array of layeredMatches to search (DEFAULT is [0])
-     * @param context - Processing context for license-aware evaluation
-     * @returns Promise resolving to the fallback BaseElement
-     */
-    static baseFallbackElement(currentVariant: Variant, elementName: string, layeredMatches: Variant[], context?: ProcessingContext): Promise<BaseElement>;
-    /**
-     * Adds an element to the default variant's element collection.
-     * Used when an element doesn't exist in any baseline variant and must be
-     * added to the default variant to maintain parity.
-     *
-     * @param variant - The variant containing the element to add
-     * @param elementName - The name of the element to add to default
-     * @param defaultVariant - The default variant to receive the new element
-     * @param context - Processing context for license-aware evaluation
-     * @returns Promise resolving to the newly created BaseElement
-     */
-    static addElementToDefault(variant: Variant, elementName: string, defaultVariant: Variant, context?: ProcessingContext): Promise<BaseElement>;
-}

package/dist/Component/Variants/Variant.d.ts

@@ -1,55 +0,0 @@
-import { Elements } from '../Elements/Elements.js';
-import type { Children } from '../Children/Children.js';
-import type { ResolvedConfig, Variant as AnovaVariant } from '@directededges/specs-schema';
-import { FigmaVariantProp } from '../../Utilities/Utilities.js';
-import { Layout } from '../Layout/Layout.js';
-import type { FigmaElementNode } from '../Nodes/types.js';
-import type { ProcessingContext } from '../../Runtime/Context/interfaces.js';
-import { PropPairings } from '../Props/PropPairings.js';
-import type { PropPairCandidate } from '../Props/PropPair.js';
-export type VariantBaseline = 'DEFAULT' | Variant;
-export type VariantConfiguration = Record<string, string | number | boolean>;
-export declare class Variant {
-    name: string;
-    node: ComponentNode | FrameNode | null;
-    default: boolean;
-    configuration: VariantConfiguration;
-    invalid: boolean;
-    invalidBySimplerVariant: boolean;
-    layeredMatches: Variant[];
-    full: Elements;
-    layered: Elements;
-    layout?: Layout;
-    layeredLayout?: Layout;
-    bindingPairCandidates: PropPairCandidate[];
-    config: ResolvedConfig;
-    codeOnlyContainer?: FigmaElementNode;
-    constructor(name: string, node: ComponentNode | FrameNode | null, isDefault: boolean, variantProps: FigmaVariantProp[] | undefined, config: ResolvedConfig);
-    evaluate(context?: ProcessingContext, pairings?: PropPairings): Promise<void>;
-    /**
-     * Relates raw Figma properties into semantic spec properties.
-     * Runs after evaluate() and before layer().
-     */
-    postEvaluate(): void;
-    /**
-     * Calculate layered differences by accumulating all layeredMatches.
-     */
-    layer(context?: ProcessingContext): Promise<void>;
-    postProcess(context?: ProcessingContext): Promise<void>;
-    data(subcomponentRefs?: Map<string, string>): AnovaVariant | undefined;
-    /**
-     * Get the appropriate elements based on DETAILS setting
-     */
-    get elementDetails(): Elements;
-    /**
-     * Get the appropriate layout based on DETAILS setting
-     */
-    get layoutDetails(): Layout | undefined;
-    /**
-     * Return the Children instance for a named slot element, or undefined.
-     * Used by the SlotContent collaborator to call setExample() on `full` before
-     * layer() runs, so variant differencing captures example-reference differences.
-     */
-    getSlotChildren(elementName: string): Children | undefined;
-    private nonDefaultConfigurations;
-}

package/dist/Component/Variants/Variants.d.ts

@@ -1,91 +0,0 @@
-import { Anatomy } from "../Anatomy/Anatomy.js";
-import { Variant, VariantConfiguration } from "./Variant.js";
-import { ResolvedConfig, Variants as AnovaVariants } from '@directededges/specs-schema';
-import { SpecableNode } from "../Nodes/types.js";
-import { ProgressCoordinator } from '../../Progress/ProgressCoordinator.js';
-import { type ProcessingContext } from '../../Runtime/Context/interfaces.js';
-import { PropPairings } from '../Props/PropPairings.js';
-export declare class Variants {
-    private _items;
-    _invalidVariants: VariantConfiguration[];
-    pairings: PropPairings;
-    private _node;
-    private _variantProps;
-    private _anatomy;
-    private config;
-    constructor(node: SpecableNode, anatomy: Anatomy, config: ResolvedConfig);
-    process(coordinator?: ProgressCoordinator, context?: ProcessingContext): Promise<void>;
-    private initialize;
-    /**
-     * Populate layeredMatches array for each variant.
-     * Layered matches are ALL variants with matching subset configurations (not just N-1).
-     * This enables CSS cascade-style layering where each variant accumulates
-     * all matching layers before comparing.
-     */
-    private setLayeredMatches;
-    private evaluate;
-    /**
-     * Relates raw Figma properties into semantic spec properties for all variants.
-     * Runs after evaluate() and before layer() so computed values
-     * are available for variant differencing.
-     */
-    private postEvaluate;
-    /**
-     * Calculate layered differences for all variants.
-     * For each variant (in sorted order), accumulates all layeredMatches' .layered
-     * differences, then compares current variant to determine incremental changes.
-     *
-     * Processing order is critical: variants are sorted by config count, so all
-     * layeredMatches are processed before the current variant.
-     */
-    layer(coordinator?: ProgressCoordinator, context?: ProcessingContext): Promise<void>;
-    resolve(context?: ProcessingContext): Promise<void>;
-    data(subcomponentRefs?: Map<string, string>): AnovaVariants;
-    /**
-     * Get the default variant (first variant, baseline === 'DEFAULT')
-     */
-    getDefault(): Variant | undefined;
-    /**
-     * Returns an iterator over variants.
-     * @example
-     * for (const variant of variants.entries()) {
-     *   await variant.process();
-     * }
-     */
-    entries(): IterableIterator<Variant>;
-    /**
-     * Returns an iterator over variants (alias for entries).
-     * @example
-     * for (const variant of variants.values()) {
-     *   console.log(variant.name);
-     * }
-     */
-    values(): IterableIterator<Variant>;
-    /**
-     * Makes Variants directly iterable.
-     * @example
-     * for (const variant of variants) {
-     *   console.log(variant.name);
-     * }
-     */
-    [Symbol.iterator](): IterableIterator<Variant>;
-    /**
-     * Returns the number of variants in the collection.
-     */
-    get size(): number;
-    /**
-     * Checks if the collection is empty.
-     * @example
-     * if (variants.isEmpty()) {
-     *   return;
-     * }
-     */
-    isEmpty(): boolean;
-    /**
-     * Generate all possible variant names from variant properties.
-     * Returns an ordered array of variant names, respecting VARIANT_DEPTH setting.
-     */
-    private generateVariantNames;
-    private completeConfiguration;
-    private invalidCombinations;
-}

package/dist/Components/Components.d.ts

@@ -1,68 +0,0 @@
-/**
- * Components — Sole public entry point for REST/CLI runtime
- *
- * `Components.fromRestApi(ids, json, config, foundations, onProgress, license?)`
- *
- * Returns `ComponentsData[]` — a union of success and error entries.
- * License is validated once per invocation. `Component` is internal.
- *
- * @example REST/CLI usage
- * ```typescript
- * const results = await Components.fromRestApi(
- *   ['btn-primary', 'btn-secondary'],
- *   figmaFileJson,
- *   config,
- *   { styles, variables, collections },
- *   (event) => console.log(`${event.index + 1}/${event.total}: ${event.component}`),
- *   { key: 'lic_xxx' },
- * );
- * ```
- */
-import type { ResolvedConfig, Component as AnovaComponent } from '@directededges/specs-schema';
-import type { StylesMap, VariablesMap, CollectionsMap } from '../Runtime/Foundations/FigmaRESTMaps.js';
-import type { RestLicenseInput } from '../License/types.js';
-/** Component output data — success or error per component */
-export type ComponentsData = {
-    name: string;
-    component: AnovaComponent;
-} | {
-    name: string;
-    error: string;
-};
-/** Progress event emitted for each component */
-export type ProgressEvent = {
-    component: string;
-    index: number;
-    total: number;
-    status: 'processing' | 'success' | 'error';
-    error?: string;
-};
-/** Foundations data for REST processing */
-export interface RestFoundations {
-    styles: StylesMap;
-    variables: VariablesMap;
-    collections: CollectionsMap;
-    author?: string;
-    generator?: {
-        name: string;
-        version: string;
-        url: string;
-    };
-}
-export declare class Components {
-    /**
-     * Process one or more components from REST API JSON data.
-     *
-     * License is validated once per batch call. All components share the same
-     * ProcessingContext with the resolved license result.
-     *
-     * @param componentIds - Array of component names or IDs to extract
-     * @param figmaFileJson - Raw REST API JSON data
-     * @param config - Component configuration
-     * @param foundations - Required: styles, variables, collections Maps
-     * @param onProgress - Progress callback, fired per component
-     * @param license - Optional license key for premium features
-     * @returns Array of ComponentsData (success or error per component)
-     */
-    static fromRestApi(componentIds: string[], figmaFileJson: unknown, config: ResolvedConfig, foundations: RestFoundations, onProgress: (event: ProgressEvent) => void, license?: RestLicenseInput): Promise<ComponentsData[]>;
-}

package/dist/Config/types.Settings.d.ts

@@ -1,30 +0,0 @@
-export type Settings = {
-    DATA_VARIANT_NAMES: boolean;
-    DATA_EMPTY_VARIANTS: boolean;
-    DATA_INVALID_VARIANT: boolean;
-    DATA_INVALID_COMBINATIONS: boolean;
-    DATA_LAYOUT: 'LAYOUT' | 'PARENT_CHILDREN' | 'BOTH';
-    DATA_STYLES_VARIABLE_FORMAT: 'NAME_WITH_COLLECTION' | 'NAME' | 'OBJECT';
-    DETAILS: 'FULL' | 'LAYERED';
-    OUTPUT: boolean;
-    OUTPUT_REPLACE: boolean;
-    OUTPUT_DATA: boolean;
-    OUTPUT_STYLING: boolean;
-    OUTPUT_ANATOMY: boolean;
-    OUTPUT_LAYOUT: boolean;
-    OUTPUT_PROPS: boolean;
-    OUTPUT_MODES: boolean;
-    ANATOMY_CONTENT: 'CANVAS' | 'DEV_MODE';
-    ANATOMY_EXPOSE_BOOLEAN_PROP_LAYERS: boolean;
-    FORMAT_OUTPUT: 'YAML' | 'JSON';
-    FORMAT_KEYS: 'SAFE' | 'CAMEL' | 'SNAKE' | 'KEBAB' | 'PASCAL' | 'TRAIN';
-    FORMAT_COLOR: 'HEX' | 'HSLA';
-    FORMAT_CUSTOM_COLORS: boolean;
-    FORMAT_CUSTOM_SPACING: boolean;
-    FORMAT_CUSTOM_TEXT_STYLES: boolean;
-    SIMPLIFY_STYLES?: boolean;
-    SIMPLIFY_VARIABLES?: boolean;
-    SUBCOMPONENTS: boolean;
-    SUBCOMPONENT_NAME_PATTERN: string;
-    VARIANT_DEPTH: 1 | 2 | 3 | 9999;
-};

package/dist/Constants/ApiMappings.d.ts

@@ -1,31 +0,0 @@
-/**
- * API-specific property mappings for REST API vs Plugin API
- *
- * The Figma REST API and Plugin API have different node structures:
- * - REST API: Typography properties in node.style.* (fontSize, fontFamily, etc.)
- * - Plugin API: Typography properties at top level (node.fontSize, node.fontName.*, etc.)
- */
-/**
- * Properties that exist in node.style.* for REST API TEXT nodes
- * These are accessed directly from node.style[key] in REST API
- */
-export declare const REST_TEXT_PROPERTIES: readonly ["fontSize", "letterSpacing", "textCase", "textDecoration", "leadingTrim", "paragraphIndent", "paragraphSpacing", "listSpacing", "hangingPunctuation", "hangingList"];
-/**
- * Properties that exist in node.style.* for REST API but need special handling
- */
-export declare const REST_FONT_PROPERTIES: readonly ["fontFamily", "fontStyle"];
-/**
- * Mapping from our style keys to Plugin API node.fontName properties
- * Used to access node.fontName[FONT_NAME_MEMBER_MAP[key]] in Plugin API
- */
-export declare const FONT_NAME_MEMBER_MAP: Record<string, string>;
-/**
- * Line height properties in REST API node.style.*
- */
-export declare const REST_LINE_HEIGHT_PROPERTIES: {
-    readonly unit: "lineHeightUnit";
-    readonly percentFontSize: "lineHeightPercentFontSize";
-    readonly px: "lineHeightPx";
-};
-export type RestTextProperty = typeof REST_TEXT_PROPERTIES[number];
-export type RestFontProperty = typeof REST_FONT_PROPERTIES[number];

package/dist/Constants/BindingKeys.d.ts

@@ -1,2 +0,0 @@
-import { BindingKey } from '../Utilities/types.ReferenceValue';
-export declare const BINDING_KEY_MAP: Record<string, BindingKey>;

package/dist/Constants/DevSettings.d.ts

@@ -1,4 +0,0 @@
-export type DevSettings = {
-    CONSOLE_LOGGING_MAJOR?: boolean;
-};
-export declare const DEV_SETTINGS: DevSettings;

package/dist/Constants/Nodes.d.ts

@@ -1 +0,0 @@
-export declare const FIGMA_ELEMENT_NODE_TYPES: readonly ["COMPONENT", "FRAME", "INSTANCE", "TEXT", "VECTOR", "LINE", "STAR", "POLYGON", "RECTANGLE", "ELLIPSE", "SLOT"];

package/dist/License/LicenseManager.d.ts

@@ -1,43 +0,0 @@
-/**
- * LicenseManager — resolves license input to a LicenseResult for use in
- * the component processing pipeline.
- *
- * Two paths:
- *  - Plugin: receives a pre-resolved LicenseState from the Plugin UI thread.
- *    No network calls are made from the transformer.
- *  - REST/CLI: sends the raw key to specs-license-proxy and maps the
- *    proxy's verdict to a LicenseState.
- *
- * Runtime enforcement (CP-09): the `runtime` parameter — set by the factory
- * method, not the caller — determines which input path is used. REST always
- * validates via the proxy, even if the input object has a `state` field.
- */
-import type { LicenseState, LicenseRuntime, LicenseInput, LicenseResult } from './types.js';
-/**
- * Resolve license input to a LicenseResult.
- *
- * Runtime enforcement (CP-09): the `runtime` parameter determines which input
- * path is accepted. Only the plugin runtime reads `input.state`; the REST path
- * always validates via the proxy regardless of what fields the input carries.
- *
- * Plugin path (`PluginLicenseInput`): reads `input.state` directly — no network call.
- * REST/CLI path (`RestLicenseInput`): calls the license proxy.
- * Absent input: returns free-tier result with status 'none'.
- *
- * @throws Never — all error paths are mapped to a LicenseResult carrying the
- *         appropriate LicenseState (error, invalid, network-error, etc.).
- */
-export declare function resolve(input: LicenseInput | undefined, runtime: LicenseRuntime): Promise<LicenseResult>;
-/**
- * Mask a license key for use in non-secure contexts (debug descriptions, etc.).
- * Never call this to produce serialised component output — only descriptions.
- *
- * @example maskKey('abcdefxyz') → '***xyz'
- */
-export declare function maskKey(key: string): string;
-/**
- * Return a neutral, factual description for a given LicenseState.
- * The transformer MUST NOT include user-facing advice or resolution steps.
- * That is the responsibility of the calling environment (CLI, Plugin).
- */
-export declare function descriptionFor(state: LicenseState, maskedKey?: string): string;

package/dist/License/ProxyClient.d.ts

@@ -1,25 +0,0 @@
-/**
- * ProxyClient — calls the specs-license-proxy Cloudflare Worker.
- *
- * The proxy owns all license logic (key validation, tier resolution,
- * meter checks, credit consumption). This module sends a minimal
- * request and returns the proxy's verdict.
- *
- * Only executed on the REST/CLI path (never in the Plugin sandbox).
- */
-import type { LicenseRuntime } from './types.js';
-export interface ProxyResponse {
-    /** Numeric tier: 0 = unauthorized (fail loud), 1 = PRO, 3 = PARTNER */
-    response: number;
-    /** Machine-readable status code */
-    status: string;
-    /** User-facing message */
-    detail: string;
-}
-/**
- * POST `{ key, runtime }` to the proxy and return its verdict.
- *
- * - On fetch failure: throws (LicenseManager catches as network-error).
- * - On non-JSON / unexpected HTTP: returns `{ response: 0, status: "network-error", detail }`.
- */
-export declare function callProxy(key: string, runtime: LicenseRuntime): Promise<ProxyResponse>;

package/dist/License/constants.d.ts

@@ -1,41 +0,0 @@
-/**
- * Licensing constants for specs-from-figma
- *
- * All validation logic now lives in specs-license-proxy (Cloudflare Worker).
- * This module retains tier constants and the LICENSING config object.
- */
-/** Public license levels */
-export declare const FREE: "FREE";
-export declare const PRO: "PRO";
-/**
- * @internal Enterprise level — not exported from package.
- * Encoded to resist casual code inspection in standard build.
- */
-export declare const _E: string;
-/**
- * @internal Partner level — not exported from package.
- * Encoded to resist casual code inspection in standard build.
- */
-export declare const _P: string;
-/** Tier numbers — higher tiers include all lower-tier entitlements */
-export declare const TIERS: Record<string, number>;
-/**
- * Derive tier number from level string.
- * Returns 0 (FREE) for any unrecognised level.
- */
-export declare function tierForLevel(level: string): number;
-export declare const LICENSING: {
-    /**
-     * Polar environment. Set POLAR_ENV=SANDBOX to target the sandbox for testing.
-     * Defaults to PRODUCTION.
-     *
-     * Lazy getter: `process.env` is only read when a REST/CLI validation call is
-     * actually made — never at module load time, so this is safe to bundle into
-     * the Figma plugin (where `process` is undefined).
-     */
-    readonly ENVIRONMENT: "SANDBOX" | "PRODUCTION";
-    /** Proxy URL for license validation (all logic lives in the proxy) */
-    readonly PROXY_URL: string;
-    /** User-facing store URL */
-    readonly STORE_URL: string;
-};

package/dist/License/types.d.ts

@@ -1,83 +0,0 @@
-/**
- * License types for specs-from-figma
- *
- * These types define the contract for license validation and gating.
- */
-/**
- * Discriminated union of all possible license states.
- * Mirrors the POC canonical set + `unlocked` for compile-time enterprise builds.
- */
-export type LicenseState = {
-    status: 'none';
-} | {
-    status: 'validating';
-} | {
-    status: 'active';
-    expiresAt: string | null;
-    organizationName?: string;
-} | {
-    status: 'usage-limit-reached';
-    usageCount: number;
-    usageLimit: number;
-} | {
-    status: 'invalid';
-} | {
-    status: 'wrong-runtime';
-} | {
-    status: 'expired';
-    expiresAt: string;
-} | {
-    status: 'removed';
-} | {
-    status: 'network-error';
-} | {
-    status: 'error';
-    message: string;
-} | {
-    status: 'unlocked';
-};
-export type LicenseStatusCode = LicenseState['status'];
-/**
- * Which calling environment is invoking the transformer.
- * Sent to the license proxy to determine runtime-specific entitlements.
- */
-export type LicenseRuntime = 'plugin' | 'cli';
-/**
- * Plugin path: the Plugin UI thread has already validated externally.
- * The transformer receives the pre-resolved state and does not make network calls.
- */
-export type PluginLicenseInput = {
-    state: LicenseState;
-};
-/**
- * REST/CLI path: the transformer validates the key via the license proxy.
- * The caller passes the raw key; runtime is supplied by the factory method.
- */
-export type RestLicenseInput = {
-    key: string;
-};
-/**
- * Dual-path union.
- * - `fromPlugin()` accepts `PluginLicenseInput`
- * - `fromRestApi()` / `Components.fromRestApi()` accept `RestLicenseInput`
- */
-export type LicenseInput = PluginLicenseInput | RestLicenseInput;
-/**
- * Resolved outcome threaded through ProcessingContext for every processing call.
- * `tier` is the numeric gate used by `entitled()` throughout the pipeline.
- * `level` is the human-readable string stamped into `generator.license.level` output.
- */
-export type LicenseResult = {
-    /** The resolved machine-readable state */
-    state: LicenseState;
-    /** true only when status === 'active' AND the license covers the calling runtime's benefit */
-    isLicensed: boolean;
-    /** Neutral factual description — the transformer's responsibility only; callers add their own UX copy */
-    description: string;
-    /** Masked key (`***xyz`), present on error states where key context aids debugging */
-    maskedKey?: string;
-    /** Human-readable license level: "FREE", "PRO", "ENTERPRISE", "PARTNER" */
-    level: string;
-    /** Numeric tier for gating: 0=FREE, 1=PRO, 2=ENTERPRISE, 3=PARTNER. Derived from level. */
-    tier: number;
-};

package/dist/Progress/PhaseConfiguration.d.ts

@@ -1,20 +0,0 @@
-import type { Settings } from '../Config/types.Settings.js';
-/**
- * Phase configuration for progress tracking
- * Determines which phases are active based on settings
- */
-export interface PhaseConfiguration {
-    /** Ordered list of phase names that will be executed */
-    phases: string[];
-    /** Total number of steps for progress display */
-    totalSteps: number;
-    /** Set of phase names that support chunking */
-    chunkablePhases: Set<string>;
-}
-/**
- * Build phase configuration based on enabled output settings
- * Calculates total step count dynamically
- * @param settings - Plugin settings with output section flags
- * @returns Phase configuration object
- */
-export declare function buildPhaseConfiguration(settings: Settings): PhaseConfiguration;

package/dist/Progress/Progress.d.ts

@@ -1,107 +0,0 @@
-/**
- * Progress tracking types for component processing
- * @module UI/Types/Progress
- */
-/**
- * Progress state for UI display
- * Immutable snapshot of current processing phase
- */
-export interface ProgressState {
-    /**
-     * Human-readable phase name (e.g., "Evaluating variants", "Outputting Props")
-     * Must match console output phase names for consistency
-     */
-    phase: string;
-    /**
-     * Current step number (1-indexed for display)
-     * e.g., 2 means "Step 2 of 8"
-     */
-    currentStep: number;
-    /**
-     * Total number of steps for this processing run
-     * Calculated dynamically based on enabled output sections
-     * Range: 3-9 depending on settings
-     */
-    totalSteps: number;
-    /**
-     * Optional chunk information for variant-heavy phases
-     * Only present when processing >10 variants in evaluate/layer phases
-     */
-    chunkInfo?: ChunkInfo;
-    /**
-     * Optional percentage completion (0-100)
-     * Future enhancement (P3) - requires timing estimates
-     * When present, UI may display "42%" instead of "Step 2 of 8"
-     */
-    percentage?: number;
-}
-/**
- * Chunk progress information
- * Used when processing >10 variants in evaluate or layer phases
- */
-export interface ChunkInfo {
-    /**
-     * Start index of chunk (1-indexed for display)
-     * e.g., 1, 11, 21 for successive chunks
-     */
-    start: number;
-    /**
-     * End index of chunk (1-indexed, inclusive)
-     * e.g., 10, 20, 30 for successive chunks
-     */
-    end: number;
-}
-/**
- * Timing data for a completed processing phase
- * Collected by TimingCollector for console.table() output
- */
-export interface TimingEntry {
-    /**
-     * Phase name (must match ProgressState.phase)
-     * e.g., "Setting up variants", "Evaluating variants"
-     */
-    phase: string;
-    /**
-     * Start timestamp from performance.now()
-     */
-    startTime: number;
-    /**
-     * End timestamp from performance.now()
-     * Undefined if phase is still in progress
-     */
-    endTime?: number;
-}
-/**
- * Callback function invoked when progress state changes
- */
-export type ProgressCallback = (state: ProgressState) => void;
-/**
- * Human-readable phase names
- * Used for both UI display and console output
- */
-export declare const PHASE_NAMES: {
-    readonly SETUP_VARIANTS: "Setting up variants";
-    readonly EVALUATE_VARIANTS: "Evaluating variants";
-    readonly LAYER_VARIANTS: "Layering variants";
-    readonly OUTPUT_DATA: "Outputting data";
-    readonly OUTPUT_ANATOMY: "Outputting Anatomy";
-    readonly OUTPUT_PROPS: "Outputting Props";
-    readonly OUTPUT_LAYOUT: "Outputting Layout";
-    readonly OUTPUT_STYLING: "Outputting Styling";
-    readonly OUTPUT_MODES: "Outputting Modes";
-};
-/**
- * Variant count threshold for chunking
- * When variant count > CHUNK_THRESHOLD, display chunk progress
- */
-export declare const CHUNK_THRESHOLD = 10;
-/**
- * Chunk size for splitting variant processing
- * Each chunk processes CHUNK_SIZE variants before progress update
- */
-export declare const CHUNK_SIZE = 10;
-/**
- * Minimum display time per phase (milliseconds)
- * UI will delay transitions to ensure each phase visible for at least this duration
- */
-export declare const MIN_PHASE_DISPLAY_MS = 100;