@wireweave/core 3.1.0-beta.3 → 3.1.0-beta.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/index.d.ts CHANGED
@@ -1,7 +1,10 @@
1
- import { h as AnyNode, A as AccordionNode, a as AlertNode, j as AvatarNode, B as BadgeNode, r as BreadcrumbNode, s as ButtonNode, C as CardNode, w as CheckboxNode, x as ColNode, z as ContainerComponentNode, D as ContainerNode, E as DataNode, H as DisplayNode, I as DividerComponentNode, K as DrawerNode, N as DropdownNode, O as FeedbackNode, Q as FooterNode, R as GridNode, T as HeaderNode, V as IconNode, Y as ImageNode, Z as InputComponentNode, _ as InputNode, a2 as LayoutDefinitionNode, a3 as LayoutNode, a4 as LeafNode, a5 as LinkNode, a7 as ListNode, a8 as MainNode, ab as ModalNode, ah as NavNode, ai as NavigationNode, aj as NodeType, ak as OverlayNode, al as PageNode, am as PlaceholderNode, an as PopoverNode, aq as ProgressNode, ar as RadioNode, at as RowNode, au as SectionNode, av as SelectNode, ay as SidebarNode, aA as SliderNode, aB as SlotNode, aF as SpinnerNode, aJ as SwitchNode, aL as TableNode, aM as TabsNode, aO as TextContentNode, aP as TextNode, aT as TextareaNode, aV as TitleNode, aW as ToastNode, aY as TooltipNode, b1 as WireframeDocument, F as DefinitionNode, aC as SourceLocation, $ as InputType } from './types-BDaNyWMR.js';
2
- export { b as AlertVariant, c as AlignValue, d as AnchorPosition, e as AnnotationItemNode, f as AnnotationNode, g as AnnotationsNode, i as AppearanceProps, k as AvatarSize, l as AvatarSizeToken, m as BadgeSize, n as BadgeSizeToken, o as BadgeVariant, p as BaseNode, q as BreadcrumbItem, t as ButtonSize, u as ButtonSizeToken, v as ButtonVariant, y as CommonProps, G as DirectionValue, J as DividerNode, L as DrawerPosition, M as DropdownItemNode, P as FlexProps, S as GridProps, U as HeightValue, W as IconSize, X as IconSizeToken, a0 as InteractiveProps, a1 as JustifyValue, a6 as ListItemNode, a9 as MarkerColor, aa as MarkerNode, ac as NavBlockItem, ad as NavChild, ae as NavDivider, af as NavGroupNode, ag as NavItem, ao as Position, ap as PositionProps, as as RelativeNode, aw as SelectOption, ax as ShadowValue, az as SizeProps, aD as SpacingProps, aE as SpacingValue, aG as SpinnerSize, aH as SpinnerSizeToken, aI as StackNode, aK as TabNode, aN as TextAlign, aQ as TextSize, aR as TextSizeToken, aS as TextWeight, aU as TitleLevel, aX as ToastPosition, aZ as TooltipPosition, a_ as TopLevelNode, a$ as ValueWithUnit, b0 as WidthValue } from './types-BDaNyWMR.js';
1
+ import { h as AnyNode, A as AccordionNode, a as AlertNode, j as AvatarNode, B as BadgeNode, r as BreadcrumbNode, s as ButtonNode, C as CardNode, w as CheckboxNode, x as ColNode, z as ComponentDefinitionNode, H as ComponentUseNode, I as ContainerComponentNode, J as ContainerNode, K as DataNode, L as DefinitionNode, N as DisplayNode, O as DividerComponentNode, P as DrawerNode, S as DropdownNode, T as FeedbackNode, V as FooterNode, W as GridNode, Z as HeaderNode, $ as IconNode, a2 as ImageNode, a3 as InputComponentNode, a4 as InputNode, aa as LayoutDefinitionNode, ab as LayoutNode, ac as LeafNode, ad as LinkNode, af as ListNode, ag as MainNode, aj as ModalNode, ao as NavNode, ap as NavigationNode, aq as NodeType, ar as OverlayNode, as as PageNode, at as PlaceholderNode, au as PopoverNode, ax as ProgressNode, ay as RadioNode, aA as RowNode, aB as SectionNode, aC as SelectNode, aF as SidebarNode, aH as SliderNode, aI as SlotNode, aM as SpinnerNode, aU as SwitchNode, aW as TableNode, aX as TabsNode, aZ as TextContentNode, a_ as TextNode, b2 as TextareaNode, b4 as TitleNode, b5 as ToastNode, b7 as TooltipNode, bc as WireframeDocument, aJ as SourceLocation, aQ as StateDeclaration, aR as StateGuard, a6 as InteractionEffect, a5 as InputType } from './types-BiDAgo6f.js';
2
+ export { b as AlertVariant, c as AlignValue, d as AnchorPosition, e as AnnotationItemNode, f as AnnotationNode, g as AnnotationsNode, i as AppearanceProps, k as AvatarSize, l as AvatarSizeToken, m as BadgeSize, n as BadgeSizeToken, o as BadgeVariant, p as BaseNode, q as BreadcrumbItem, t as ButtonSize, u as ButtonSizeToken, v as ButtonVariant, y as CommonProps, D as ComponentInputValue, E as ComponentParameter, F as ComponentParameterType, G as ComponentSlotFill, M as DirectionValue, Q as DrawerPosition, R as DropdownItemNode, U as FlexProps, X as GridProps, Y as GuardedOutcomeProps, _ as HeightValue, a0 as IconSize, a1 as IconSizeToken, a7 as InteractionHandler, a8 as InteractiveProps, a9 as JustifyValue, ae as ListItemNode, ah as MarkerColor, ai as MarkerNode, ak as NavBlockItem, al as NavChild, am as NavGroupNode, an as NavItem, av as Position, aw as PositionProps, az as RelativeNode, aD as SelectOption, aE as ShadowValue, aG as SizeProps, aK as SpacingProps, aL as SpacingValue, aN as SpinnerSize, aO as SpinnerSizeToken, aP as StackNode, aS as StateValue, aT as StateValueType, aV as TabNode, aY as TextAlign, a$ as TextSize, b0 as TextSizeToken, b1 as TextWeight, b3 as TitleLevel, b6 as ToastPosition, b8 as TooltipPosition, b9 as TopLevelNode, ba as ValueWithUnit, bb as WidthValue } from './types-BiDAgo6f.js';
3
3
  export { ExpectedToken, ParseError, ParseErrorInfo, ParseOptions, ParseResult, getErrors, isValid, parse, tryParse } from './parser.js';
4
- export { CanvasOptions, CanvasRenderResult, HtmlRenderer, IconData, IconElement, InteractiveAttrs, PageRenderResult, PlacedPage, RenderContext, RenderOptions, RenderResult, ShellMiss, SiteModel, SiteOptions, SiteScreen, SiteShell, SvgRenderOptions, SvgRenderResult, ThemeColors, ThemeConfig, anchorIntent, buildSiteModel, createHtmlRenderer, darkTheme, defaultTheme, generateComponentStyles, generateStyles, getIconData, getTheme, layoutCanvas, lucideIcons, render, renderCanvas, renderIconSvg, renderPage, renderSite, renderToHtml, renderToSvg, renderUnknownIconSvg, resolvePageDimensions } from './renderer.js';
4
+ import { SiteOptions } from './renderer.js';
5
+ export { AnnotationStyle, CanvasOptions, CanvasRenderResult, ENABLED_GUARD_ATTR, EXTERNAL_NAVIGATE_ATTR, HtmlRenderer, INERT_HREF, INTERACTIVE_ATTR_NAMES, IconData, IconElement, InteractiveAttrs, PageRenderResult, PlacedPage, RenderContext, RenderOptions, RenderResult, ShellMiss, SiteModel, SiteScreen, SiteShell, SvgRenderOptions, SvgRenderResult, TYPED_INTERACTION_ATTR, ThemeColors, ThemeConfig, VISIBLE_GUARD_ATTR, anchorIntent, buildSiteModel, createHtmlRenderer, darkTheme, defaultTheme, generateComponentStyles, generateStyles, getIconData, getTheme, guardedOutcomeAttrs, interactiveAttrs, layoutCanvas, lucideIcons, render, renderCanvas, renderIconSvg, renderPage, renderSite, renderToHtml, renderToSvg, renderUnknownIconSvg, resolvePageDimensions } from './renderer.js';
6
+ import { ComponentCategory } from './spec.js';
7
+ export { ATTRIBUTE_MAP, ATTRIBUTE_OVERRIDES, ATTRIBUTE_SPECS, AttributeOverride, AttributeSpec, AttributeValueType, BLOCK_NODE_SPECS, BOX_ATTRIBUTES, COMPONENT_MAP, COMPONENT_NAMES, COMPONENT_SPECS, COMPONENT_SPEC_BY_NAME, CONTAINER_ATTRIBUTES, ComponentSpec, ELEMENT_NODE_TYPE_MAP, GRAMMAR_BLOCK_NODE_TYPES, GRAMMAR_CHILD_KEYWORDS, GRAMMAR_ELEMENTS, GrammarBlockNodeType, GrammarElementName, GrammarNodeType, INTERACTIVE_ATTRIBUTES, LUCIDE_ICON_NAMES, NODE_TYPE_MAP, VALID_ATTRIBUTE_NAMES, VALID_COMPONENT_NAMES, attributeFor, getValidAttributes, isValidAttribute } from './spec.js';
5
8
 
6
9
  /**
7
10
  * Type guards for wireweave AST
@@ -16,7 +19,11 @@ declare function hasChildren(node: AnyNode): node is AnyNode & {
16
19
  declare function isLeafNode(node: AnyNode): node is LeafNode;
17
20
  declare function isLayoutNode(node: AnyNode): node is LayoutNode;
18
21
  declare function isPageNode(node: AnyNode): node is PageNode;
22
+ /** A `layout` or `component` definition — a named tree, not a screen. */
23
+ declare function isDefinitionNode(node: AnyNode): node is DefinitionNode;
19
24
  declare function isLayoutDefinitionNode(node: AnyNode): node is LayoutDefinitionNode;
25
+ declare function isComponentDefinitionNode(node: AnyNode): node is ComponentDefinitionNode;
26
+ declare function isComponentUseNode(node: AnyNode): node is ComponentUseNode;
20
27
  declare function isSlotNode(node: AnyNode): node is SlotNode;
21
28
  declare function isHeaderNode(node: AnyNode): node is HeaderNode;
22
29
  declare function isMainNode(node: AnyNode): node is MainNode;
@@ -97,19 +104,32 @@ declare function walk(node: AnyNode, callback: WalkCallback, parent?: AnyNode, d
97
104
  /**
98
105
  * Walk through a document's AST
99
106
  *
107
+ * Covers every top-level child — pages *and* reuse definitions — because a walk
108
+ * is about visiting nodes, not about selecting screens.
109
+ *
100
110
  * @param document - The wireframe document
101
111
  * @param callback - Function called for each node
102
112
  */
103
113
  declare function walkDocument(document: WireframeDocument, callback: WalkCallback): void;
104
114
  /**
105
- * Return only the document's pages, in source order.
115
+ * The document's pages, in source order.
116
+ *
117
+ * A document's children are not all screens: `layout` and `component`
118
+ * definitions sit alongside `page` as top-level siblings. Anything that counts,
119
+ * indexes, renders or exports *screens* must select them through this helper
120
+ * rather than reading `document.children` directly — otherwise a definition
121
+ * silently becomes screen #0.
106
122
  *
107
- * Layout definitions share the document's top-level list with pages but are
108
- * not screens. Page-indexed consumers must use this helper so a definition
109
- * never becomes an accidental page.
123
+ * @param document - The wireframe document
124
+ * @returns Only the `Page` children
110
125
  */
111
126
  declare function documentPages(document: WireframeDocument): PageNode[];
112
- /** Return the document's named layout definitions, in source order. */
127
+ /**
128
+ * The document's reuse definitions (`layout` / `component`), in source order.
129
+ *
130
+ * @param document - The wireframe document
131
+ * @returns Only the definition children
132
+ */
113
133
  declare function documentDefinitions(document: WireframeDocument): DefinitionNode[];
114
134
  /**
115
135
  * Find the first node matching a predicate
@@ -297,103 +317,6 @@ interface PreviewWrapperOptions {
297
317
  */
298
318
  declare function wrapInPreviewContainer(html: string, viewport: ViewportSize, options?: PreviewWrapperOptions): string;
299
319
 
300
- /**
301
- * Types for Wireweave DSL Specification
302
- */
303
- /**
304
- * Attribute value type
305
- */
306
- type AttributeValueType = 'boolean' | 'number' | 'string' | 'string[]' | 'enum';
307
- /**
308
- * Attribute definition
309
- */
310
- interface AttributeSpec {
311
- /** Attribute name */
312
- name: string;
313
- /** Value type */
314
- type: AttributeValueType;
315
- /** Enum values (if type is 'enum') */
316
- values?: readonly string[];
317
- /** Description for documentation */
318
- description?: string;
319
- }
320
- /**
321
- * Component category
322
- */
323
- type ComponentCategory = 'layout' | 'grid' | 'container' | 'text' | 'input' | 'display' | 'data' | 'feedback' | 'overlay' | 'navigation' | 'annotation';
324
- /**
325
- * Component definition
326
- */
327
- interface ComponentSpec {
328
- /** Component name (lowercase, as used in DSL) */
329
- name: string;
330
- /** AST node type (PascalCase) */
331
- nodeType: string;
332
- /** Component category */
333
- category: ComponentCategory;
334
- /** Valid attributes for this component (names only, definitions in ATTRIBUTES) */
335
- attributes: readonly string[];
336
- /** Whether this component can have children */
337
- hasChildren: boolean;
338
- /** Description for documentation */
339
- description?: string;
340
- }
341
-
342
- /**
343
- * Wireweave DSL Component Definitions
344
- *
345
- * Complete list of all valid components in Wireweave DSL.
346
- * Each component specifies its valid attributes.
347
- */
348
-
349
- /**
350
- * All valid components in Wireweave DSL
351
- */
352
- declare const COMPONENT_SPECS: readonly ComponentSpec[];
353
- /**
354
- * Set of all valid component names for quick lookup
355
- */
356
- declare const VALID_COMPONENT_NAMES: ReadonlySet<string>;
357
- /**
358
- * Map of component name to spec for quick lookup
359
- */
360
- declare const COMPONENT_MAP: ReadonlyMap<string, ComponentSpec>;
361
- /**
362
- * Map of AST node type to spec for quick lookup
363
- */
364
- declare const NODE_TYPE_MAP: ReadonlyMap<string, ComponentSpec>;
365
- /**
366
- * Get valid attributes for a component (by name or node type)
367
- */
368
- declare function getValidAttributes(componentNameOrType: string): readonly string[] | undefined;
369
- /**
370
- * Check if an attribute is valid for a component
371
- */
372
- declare function isValidAttribute(componentNameOrType: string, attributeName: string): boolean;
373
-
374
- /**
375
- * Wireweave DSL Attribute Definitions
376
- *
377
- * Complete list of all valid attributes in Wireweave DSL.
378
- */
379
-
380
- /**
381
- * All valid attributes in Wireweave DSL
382
- */
383
- declare const ATTRIBUTE_SPECS: readonly AttributeSpec[];
384
- /**
385
- * Set of all valid attribute names for quick lookup
386
- */
387
- declare const VALID_ATTRIBUTE_NAMES: ReadonlySet<string>;
388
- /**
389
- * Map of attribute name to spec for quick lookup
390
- */
391
- declare const ATTRIBUTE_MAP: ReadonlyMap<string, AttributeSpec>;
392
- /**
393
- * Common attributes available to most components
394
- */
395
- declare const COMMON_ATTRIBUTES: readonly string[];
396
-
397
320
  /**
398
321
  * Wireweave DSL Validation
399
322
  *
@@ -993,6 +916,64 @@ interface AnalysisOptions {
993
916
  */
994
917
  declare function analyze(doc: WireframeDocument, options?: AnalysisOptions): AnalysisResult;
995
918
 
919
+ /** Overlay toggle is distinct from the typed boolean-state `toggle` effect. */
920
+ type NormalizedInteractionEffect = InteractionEffect | {
921
+ kind: 'toggle-overlay';
922
+ target: string;
923
+ } | {
924
+ kind: 'legacy-action';
925
+ action: string;
926
+ };
927
+ interface NormalizedInteractionHandler {
928
+ event: 'click';
929
+ guard?: StateGuard;
930
+ effects: NormalizedInteractionEffect[];
931
+ }
932
+ interface NormalizedInteraction {
933
+ screenIndex: number;
934
+ source: 'screen' | 'layout';
935
+ signature: string;
936
+ handler: NormalizedInteractionHandler;
937
+ /** Present when this entry came from a legacy scalar intent attribute. */
938
+ legacyKind?: InteractionKind;
939
+ trigger: {
940
+ nodeType: NodeType;
941
+ label?: string;
942
+ loc?: SourceLocation;
943
+ item?: {
944
+ index: number;
945
+ };
946
+ };
947
+ }
948
+ type InteractionDiagnosticCode = 'invalid-state-declaration' | 'duplicate-state-declaration' | 'invalid-interaction-handler' | 'unknown-legacy-action';
949
+ interface InteractionDiagnostic {
950
+ code: InteractionDiagnosticCode;
951
+ message: string;
952
+ screenIndex?: number;
953
+ source?: 'screen' | 'layout';
954
+ loc?: SourceLocation;
955
+ }
956
+ interface InteractionModel {
957
+ states: StateDeclaration[];
958
+ interactions: NormalizedInteraction[];
959
+ diagnostics: InteractionDiagnostic[];
960
+ }
961
+ /** Normalize a guard object emitted by the generic DSL object grammar. */
962
+ declare function normalizeStateGuard(value: unknown): StateGuard | undefined;
963
+ /**
964
+ * Normalize the public `on=` shape. Malformed handlers are inert; diagnostics
965
+ * are added by {@link collectInteractions}, where screen/source context exists.
966
+ */
967
+ declare function normalizeInteractionHandlers(value: unknown): NormalizedInteractionHandler[];
968
+ /** Stable payload shared by rendered DOM markers and the runtime registry. */
969
+ declare function interactionSignature(handler: NormalizedInteractionHandler): string;
970
+ /**
971
+ * The canonical interaction/state source for graph extraction and renderSite.
972
+ * Layout intent is expanded once per screen using that layout, so shared chrome
973
+ * has the same reachable routes in both consumers.
974
+ */
975
+ declare function collectInteractions(doc: WireframeDocument): InteractionModel;
976
+
996
977
  /**
997
978
  * Types for the deterministic extraction module.
998
979
  *
@@ -1103,8 +1084,14 @@ interface ScreenFields {
1103
1084
  }
1104
1085
  /**
1105
1086
  * A node in the screen-transition graph.
1087
+ *
1088
+ * `id` is the page's declared identifier — a stable slug an author opted into —
1089
+ * and `title` is its display heading. They are separate namespaces: `id` is what
1090
+ * a `navigate` target should key off, `title` is what a reader sees. Either can
1091
+ * be absent.
1106
1092
  */
1107
1093
  interface TransitionScreen {
1094
+ id?: string;
1108
1095
  title?: string;
1109
1096
  index: number;
1110
1097
  loc?: SourceLocation;
@@ -1115,20 +1102,32 @@ interface TransitionScreen {
1115
1102
  interface TransitionEdge {
1116
1103
  from: {
1117
1104
  pageIndex: number;
1105
+ id?: string;
1118
1106
  title?: string;
1119
1107
  };
1120
1108
  /**
1121
1109
  * The destination page for a resolved `navigate` edge. Always `null` for
1122
1110
  * `opens` / `toggles` / `action`, which are intra-page or opaque and never
1123
1111
  * cross a page boundary.
1112
+ *
1113
+ * `id` / `title` mirror {@link TransitionScreen}: present when the page
1114
+ * declares them, so a consumer can address the destination by its stable slug
1115
+ * rather than by display text.
1124
1116
  */
1125
1117
  to: {
1126
1118
  pageIndex: number;
1119
+ id?: string;
1127
1120
  title?: string;
1128
1121
  } | null;
1129
1122
  /** The raw target string as written in the DSL. */
1130
1123
  target: string;
1131
1124
  kind: InteractionKind;
1125
+ /** Typed event metadata; absent for legacy scalar interaction attributes. */
1126
+ event?: 'click';
1127
+ guard?: StateGuard;
1128
+ effect?: NormalizedInteractionEffect;
1129
+ /** A shared-layout edge is expanded once for every screen using that layout. */
1130
+ source?: 'screen' | 'layout';
1132
1131
  /**
1133
1132
  * What fired the transition. For a component node, `nodeType` is that node's
1134
1133
  * type. For a menu item inside a nav/dropdown/breadcrumb, `nodeType` is the
@@ -1145,18 +1144,27 @@ interface TransitionEdge {
1145
1144
  };
1146
1145
  };
1147
1146
  /**
1148
- * Whether `target` resolved to a concrete destination for its kind:
1149
- * - `navigate`: a page whose title matches `target`, or a URL-shaped external
1150
- * destination outside this document.
1147
+ * Whether `target` names a concrete destination for its kind:
1148
+ * - `navigate`: a page whose `id` matches `target`, or — failing that — whose
1149
+ * `title` matches it. Identifiers are consulted before display text; see
1150
+ * `extract/transitions.ts` for why. Also `true` for an `external` target: a
1151
+ * URL is a complete destination, it is simply not one of this document's
1152
+ * pages, which is why `to` is `null` there.
1151
1153
  * - `opens` / `toggles`: a `Modal` / `Drawer` with `id === target` in the
1152
1154
  * source page.
1153
1155
  * - `action`: always `false` (an opaque handler id has no structural target).
1154
1156
  */
1155
1157
  resolved: boolean;
1156
1158
  /**
1157
- * Present, and always `true`, when a `navigate` target is a URL rather than a
1158
- * page name. External edges are resolved destinations outside this document,
1159
- * so `to` remains `null` and they never appear in `dangling`.
1159
+ * Present, and always `true`, when a `navigate` target is a URL rather than
1160
+ * the name of a page (see `interaction/target.ts`). Such an edge leaves the
1161
+ * document: `to` is `null` because there is no page to point at, and it is
1162
+ * never {@link ScreenTransitionGraph.dangling | dangling} — an outbound link
1163
+ * is a destination the author meant, not a reference that failed to resolve.
1164
+ *
1165
+ * This is what separates an external link from an `action`: both have
1166
+ * `to === null`, but an `action` is an opaque handler with `resolved: false`,
1167
+ * while an external link is a real destination the browser can follow.
1160
1168
  */
1161
1169
  external?: true;
1162
1170
  }
@@ -1167,13 +1175,20 @@ interface ScreenTransitionGraph {
1167
1175
  screens: TransitionScreen[];
1168
1176
  edges: TransitionEdge[];
1169
1177
  /**
1170
- * The subset of `navigate` edges whose target matched no page title and was
1171
- * not URL-shaped (`resolved === false`, `to === null`). Intra-page
1172
- * `opens` / `toggles`, opaque `action` edges, and external URLs never appear
1173
- * here.
1178
+ * The subset of `navigate` edges whose target matched neither a page `id` nor
1179
+ * a page title and is not a URL (`resolved === false`, `to === null`) — a name
1180
+ * that was meant to be a screen and found none. This is the defect list: a
1181
+ * consumer reporting "broken transitions" counts exactly these. Intra-page
1182
+ * `opens` / `toggles` and opaque `action` edges are not page transitions and
1183
+ * never appear here, and neither do `external` links.
1174
1184
  */
1175
1185
  dangling: TransitionEdge[];
1176
- /** URL-shaped `navigate` edges that leave the current document. */
1186
+ /**
1187
+ * The subset of `navigate` edges leaving the document — targets that are URLs
1188
+ * rather than page names ({@link TransitionEdge.external}). Kept apart from
1189
+ * `dangling` so a consumer can show outbound links without counting correct
1190
+ * authoring as breakage.
1191
+ */
1177
1192
  external: TransitionEdge[];
1178
1193
  }
1179
1194
 
@@ -1196,6 +1211,9 @@ interface ScreenTransitionGraph {
1196
1211
  declare function extractScreenFields(page: PageNode): ScreenFields;
1197
1212
  /**
1198
1213
  * Extract {@link ScreenFields} for every page in a document, in document order.
1214
+ *
1215
+ * Reuse definitions are skipped: a `layout` is not a screen and has no fields
1216
+ * of its own until a page is drawn inside it.
1199
1217
  */
1200
1218
  declare function extractAllScreenFields(doc: WireframeDocument): ScreenFields[];
1201
1219
 
@@ -1213,27 +1231,60 @@ declare function extractAllScreenFields(doc: WireframeDocument): ScreenFields[];
1213
1231
  * `nav ["…"]` array items and `nav { item … group { item … } }` block items
1214
1232
  * (including grouped items), plus dropdown and breadcrumb items, are extracted.
1215
1233
  * Item triggers carry the container's type in `trigger.nodeType` and the item's
1216
- * position in `trigger.item.index`. `Tabs` items are plain strings without
1234
+ * position in `trigger.item.index`. That position counts only elements that can
1235
+ * hold an intent — dividers and group headings are skipped, in every container
1236
+ * alike — because the index is the handle that points back at an edge's origin,
1237
+ * and an element incapable of producing an edge must not shift what the handle
1238
+ * addresses. `Tabs` items are plain strings without
1217
1239
  * `InteractiveProps` and contribute no transition; their panel content is
1218
1240
  * reached by normal node traversal.
1219
1241
  *
1220
1242
  * ## Resolution semantics
1221
1243
  *
1222
- * - **`navigate`** is a page transition. Its target resolves to a page when the
1223
- * target string, trimmed, exactly matches a page `title` (case-sensitive). On
1224
- * duplicate titles the first page in document order wins. When no title
1225
- * matches, URL-shaped targets (`navigate="/dashboard"`, `https://…`) are
1226
- * reported as {@link ScreenTransitionGraph.external | external}; unmatched
1227
- * plain names remain {@link ScreenTransitionGraph.dangling | dangling}.
1244
+ * - **`navigate`** is a page transition. Its trimmed target is matched, exactly
1245
+ * and case-sensitively, against **page `id` first and page `title` second**.
1246
+ *
1247
+ * Identifiers are how this DSL names a target: `opens` / `toggles` already
1248
+ * address a `Modal` or `Drawer` by its `id`, so a page addressed by `id` is
1249
+ * the same rule reaching the one container that had been left out — an author
1250
+ * learns one way to point at something, not two.
1251
+ *
1252
+ * The two are different kinds of name. An `id` is a stable identifier the
1253
+ * author opted into (`page "결제 내역" id=billing`); a `title` is display text
1254
+ * that is optional, need not be unique, and is expected to change as copy is
1255
+ * edited. Resolving identifiers first means rewording a heading cannot
1256
+ * silently turn every edge pointing at that screen into a dangling one. Title
1257
+ * matching stays as the fallback because it is how the corpus is written
1258
+ * today, and dropping it would strand every existing document.
1259
+ *
1260
+ * Consequences of that order, all deterministic:
1261
+ * - When one page's `id` equals another page's `title`, the `id` wins and the
1262
+ * title-named page is not reachable by that string. Identifiers always beat
1263
+ * labels; there is no positional tie-break to reason about.
1264
+ * - Within each namespace, duplicates resolve to the first page in document
1265
+ * order — the same rule the title namespace has always used.
1266
+ * - A target matching neither namespace is read by shape (see `isUrlTarget`).
1267
+ * A URL-shaped one — `navigate="/reset"`, `navigate="https://…"` — is an
1268
+ * {@link ScreenTransitionGraph.external | external} destination, not a
1269
+ * defect: the DSL documents `navigate` as a "URL or page" target, so the
1270
+ * author wrote something the DSL allows and there is no page to find.
1271
+ * Anything else is a name that should have matched a page and did not, and
1272
+ * only that is {@link ScreenTransitionGraph.dangling | dangling}. Counting
1273
+ * external links as dangling would report every correct outbound link as a
1274
+ * broken screen transition.
1228
1275
  * - **`opens` / `toggles`** target an overlay *within the source page*, not
1229
1276
  * another page, so their `to` is always `null`. They resolve when a `Modal`
1230
- * or `Drawer` in the same page has `id === target` (the only nodes that carry
1231
- * an `id`). Being intra-page, they never appear in `dangling`.
1277
+ * or `Drawer` in the same page has `id === target` — the overlay containers
1278
+ * are the only nodes these two kinds can address. Being intra-page, they
1279
+ * never appear in `dangling`.
1232
1280
  * - **`action`** is an opaque handler id with no structural destination:
1233
1281
  * `to === null`, `resolved === false`, and it is not `dangling`.
1234
1282
  *
1235
1283
  * Item `href` is a raw anchor, not a declared `navigate` intent, and is
1236
- * excluded — consistent with node-level extraction.
1284
+ * excluded — consistent with node-level extraction. The HTML renderer draws the
1285
+ * same line: it emits the authored `href` and the declared intent side by side
1286
+ * as `data-navigate` / `data-opens` / `data-toggles` / `data-action`, so every
1287
+ * edge derived here has a counterpart a consumer of the markup can act on.
1237
1288
  */
1238
1289
 
1239
1290
  /**
@@ -1333,4 +1384,242 @@ declare function getNodeSource(source: string, doc: WireframeDocument, path: str
1333
1384
  */
1334
1385
  declare function buildDomTree(doc: WireframeDocument, pageIndexBase?: number): DomTreeNode[];
1335
1386
 
1336
- export { ANCHOR_LOC_ATTR, ANCHOR_PATH_ATTR, ATTRIBUTE_MAP, ATTRIBUTE_SPECS, type AccessibilityMetrics, AccordionNode, AlertNode, type AnalysisOptions, type AnalysisResult, type AnchorEntry, AnyNode, type AttributeChange, type AttributeSpec, type AttributeValueType, AvatarNode, BadgeNode, BreadcrumbNode, ButtonNode, COMMON_ATTRIBUTES, COMPONENT_MAP, COMPONENT_SPECS, CardNode, CheckboxNode, ColNode, type ComplexityMetrics, type ComponentCategory, type ComponentSpec, type ComponentStats, ContainerComponentNode, ContainerNode, type ContentAnalysis, DEFAULT_VIEWPORT, DEVICE_PRESETS, DataNode, DefinitionNode, type DiffChangeType, type DiffOptions, type DiffResult, type DiffSummary, DisplayNode, DividerComponentNode, type DomTreeNode, DrawerNode, DropdownNode, type ExportOptions, FeedbackNode, type FigmaAutoLayout, type FigmaColor, type FigmaCounterAxisAlign, type FigmaExportResult, type FigmaLayoutMode, type FigmaNode, type FigmaNodeType, type FigmaPrimaryAxisAlign, type FigmaSize, type FigmaSizingMode, type FigmaSolidFill, type FigmaStroke, type FigmaTextAlign, type FigmaTextStyle, FooterNode, GridNode, HeaderNode, IconNode, ImageNode, InputComponentNode, InputNode, InputType, type InteractionKind, type JsonExportResult, type JsonNode, type LayoutAnalysis, LayoutDefinitionNode, LayoutNode, LeafNode, LinkNode, ListNode, MainNode, ModalNode, NODE_TYPE_MAP, NavNode, NavigationNode, type NodeChange, type NodePredicate, NodeType, OverlayNode, PageNode, PlaceholderNode, PopoverNode, type PreviewWrapperOptions, ProgressNode, RadioNode, RowNode, type ScreenAction, type ScreenDisplay, type ScreenElement, type ScreenFields, type ScreenFieldsSummary, type ScreenInput, type ScreenTransitionGraph, SectionNode, SelectNode, SidebarNode, SliderNode, SlotNode, SourceLocation, type SourceSlice, SpinnerNode, SwitchNode, TableNode, TabsNode, TextContentNode, TextNode, TextareaNode, TitleNode, ToastNode, TooltipNode, type TransitionEdge, type TransitionScreen, type TreeMetrics, VALID_ATTRIBUTE_NAMES, VALID_COMPONENT_NAMES, type ValidationError, type ValidationOptions, type ValidationResult, type ViewportSize, type WalkCallback, WireframeDocument, analyze, areIdentical, buildAnchorIndex, buildDomTree, calculateViewportScale, cloneNode, contains, countNodes, diff, documentDefinitions, documentPages, exportToFigma, exportToFigmaString, exportToJson, exportToJsonString, extractAllScreenFields, extractScreenFields, extractScreenTransitions, find, findAll, findByType, formatWireframeCode, getAncestors, getChangeSummary, getDevicePresets, getMaxDepth, getNodeSource, getNodeTypes, getPageSource, getValidAttributes, getValidationErrors, hasChildren, importFromJson, isAccordionNode, isAlertNode, isAvatarNode, isBadgeNode, isBreadcrumbNode, isButtonNode, isCardNode, isCheckboxNode, isColNode, isContainerComponentNode, isContainerNode, isDataNode, isDisplayNode, isDividerNode, isDrawerNode, isDropdownNode, isFeedbackNode, isFooterNode, isGridNode, isHeaderNode, isIconNode, isImageNode, isInputComponentNode, isInputNode, isLayoutDefinitionNode, isLayoutNode, isLeafNode, isLinkNode, isListNode, isMainNode, isModalNode, isNavNode, isNavigationNode, isNodeType, isOverlayNode, isPageNode, isPlaceholderNode, isPopoverNode, isProgressNode, isRadioNode, isRowNode, isSectionNode, isSelectNode, isSidebarNode, isSliderNode, isSlotNode, isSpinnerNode, isSwitchNode, isTableNode, isTabsNode, isTextContentNode, isTextNode, isTextareaNode, isTitleNode, isToastNode, isTooltipNode, isValidAst, isValidAttribute, isValidDevicePreset, mapNodes, parseViewportString, printWireframe, resetFigmaIdCounter, resolveAnchor, resolveViewport, validate, walk, walkDocument, wrapInPreviewContainer };
1387
+ /**
1388
+ * What a `navigate` target names.
1389
+ *
1390
+ * The DSL documents `navigate` as pointing at "a URL or a page", so every target
1391
+ * is read one of two ways, and the reading decides everything downstream. A page
1392
+ * name resolves against the document and travels to the consumer as declared
1393
+ * intent; a URL is a destination the browser already knows how to reach, so it
1394
+ * belongs in the anchor and the document graph has nothing to say about it.
1395
+ *
1396
+ * The renderer and the transition extractor must read a target identically — the
1397
+ * renderer decides whether the value belongs in `href`, the extractor decides
1398
+ * whether an unmatched value is an authoring mistake. Two copies of that rule
1399
+ * would drift, and the moment they disagree one of the two starts calling
1400
+ * correct authoring a defect. So the rule lives here, below both, and neither
1401
+ * layer has to depend on the other to reach it.
1402
+ */
1403
+ /**
1404
+ * Whether a `navigate` target is a URL rather than the name of a page.
1405
+ *
1406
+ * A URL is recognised by shape, not by resolving it:
1407
+ * - a path or protocol-relative reference — `/reset`, `//cdn.example.com/x`
1408
+ * - an in-page fragment or bare query — `#terms`, `?tab=2`
1409
+ * - anything opening with an RFC 3986 scheme — `https:`, `mailto:`, `tel:`
1410
+ *
1411
+ * A target containing whitespace is never a URL: a URL carrying a space is
1412
+ * invalid until the space is percent-encoded, whereas page titles are written
1413
+ * as prose and routinely contain spaces. Screening on that first is what keeps
1414
+ * an English heading like `"Note: draft"` from reading as a scheme.
1415
+ *
1416
+ * The remaining ambiguities are decided in favour of "page", because a page name
1417
+ * is the common case and the cost of the two mistakes is not symmetric: calling
1418
+ * a page a URL yields a link that goes nowhere, while calling a URL a page
1419
+ * yields an edge reported as unresolved — visible, not silent. So a
1420
+ * schemeless host (`www.example.com`) is a page name; authors write the scheme.
1421
+ */
1422
+ declare function isUrlTarget(target: string | undefined): target is string;
1423
+
1424
+ /** A source file and exact span within it. */
1425
+ interface AppSourceSpan {
1426
+ sourceId: string;
1427
+ location: SourceLocation;
1428
+ }
1429
+ /** The two reusable definition kinds addressable by an app reference. */
1430
+ type AppDefinitionKind = 'layout' | 'component';
1431
+ /** Every stable, top-level node kind in a linked application. */
1432
+ type AppNodeKind = AppDefinitionKind | 'screen';
1433
+ /** A manifest entry assigning one module its stable application namespace. */
1434
+ interface AppManifestModule {
1435
+ id: string;
1436
+ namespace: string;
1437
+ location: SourceLocation;
1438
+ }
1439
+ /**
1440
+ * Core-owned manifest describing the modules that make up one application.
1441
+ * @public
1442
+ */
1443
+ interface AppManifest {
1444
+ id: string;
1445
+ sourceId: string;
1446
+ modules: readonly AppManifestModule[];
1447
+ }
1448
+ /** A reference to a layout or component, local to the owner namespace by default. */
1449
+ interface AppReferenceInput {
1450
+ kind: AppDefinitionKind;
1451
+ id: string;
1452
+ namespace?: string;
1453
+ source: AppSourceSpan;
1454
+ }
1455
+ interface AppNodeInput<TNode> {
1456
+ /** Stable identifier within the module namespace and node kind. */
1457
+ id: string;
1458
+ node: TNode;
1459
+ source: AppSourceSpan;
1460
+ }
1461
+ /** A layout declaration and the reusable definitions it depends on. */
1462
+ interface AppLayoutInput extends AppNodeInput<LayoutDefinitionNode> {
1463
+ references?: readonly AppReferenceInput[];
1464
+ }
1465
+ /** A component declaration and the reusable definitions it depends on. */
1466
+ interface AppComponentInput extends AppNodeInput<ComponentDefinitionNode> {
1467
+ references?: readonly AppReferenceInput[];
1468
+ }
1469
+ /** A screen declaration and the layouts/components it consumes. */
1470
+ interface AppScreenInput extends AppNodeInput<PageNode> {
1471
+ references?: readonly AppReferenceInput[];
1472
+ }
1473
+ /**
1474
+ * One parsed Wireweave module supplied to the Core linker.
1475
+ * @public
1476
+ */
1477
+ interface AppModuleInput {
1478
+ id: string;
1479
+ source: AppSourceSpan;
1480
+ layouts: readonly AppLayoutInput[];
1481
+ components: readonly AppComponentInput[];
1482
+ screens: readonly AppScreenInput[];
1483
+ }
1484
+ /** Opaque stable identity assigned by the linker. */
1485
+ type AppNodeId = string & {
1486
+ readonly __appNodeId: unique symbol;
1487
+ };
1488
+ /** Stable identity of one expanded component invocation. */
1489
+ type AppComponentInstanceId = string & {
1490
+ readonly __appComponentInstanceId: unique symbol;
1491
+ };
1492
+ /** A reference whose target has been resolved to stable app identity. */
1493
+ interface ResolvedAppReference {
1494
+ kind: AppDefinitionKind;
1495
+ id: string;
1496
+ namespace: string;
1497
+ targetId: AppNodeId;
1498
+ source: AppSourceSpan;
1499
+ }
1500
+ interface ResolvedAppNode<TKind extends AppNodeKind, TNode> {
1501
+ nodeId: AppNodeId;
1502
+ kind: TKind;
1503
+ id: string;
1504
+ moduleId: string;
1505
+ namespace: string;
1506
+ node: TNode;
1507
+ source: AppSourceSpan;
1508
+ references: readonly ResolvedAppReference[];
1509
+ }
1510
+ type ResolvedAppLayout = ResolvedAppNode<'layout', LayoutDefinitionNode>;
1511
+ type ResolvedAppComponent = ResolvedAppNode<'component', ComponentDefinitionNode>;
1512
+ type ResolvedAppScreen = ResolvedAppNode<'screen', PageNode>;
1513
+ /** Stable node-to-source mapping emitted in manifest order. */
1514
+ interface AppSourceMapEntry {
1515
+ nodeId: AppNodeId;
1516
+ source: AppSourceSpan;
1517
+ }
1518
+ /** One resolved module in a linked application document. */
1519
+ interface ResolvedAppModule {
1520
+ id: string;
1521
+ namespace: string;
1522
+ layouts: readonly ResolvedAppLayout[];
1523
+ components: readonly ResolvedAppComponent[];
1524
+ screens: readonly ResolvedAppScreen[];
1525
+ }
1526
+ /**
1527
+ * Core's dependency-closed representation of a multi-module application.
1528
+ * @public
1529
+ */
1530
+ interface AppDocument {
1531
+ type: 'AppDocument';
1532
+ id: string;
1533
+ modules: readonly ResolvedAppModule[];
1534
+ layouts: readonly ResolvedAppLayout[];
1535
+ components: readonly ResolvedAppComponent[];
1536
+ screens: readonly ResolvedAppScreen[];
1537
+ sourceMap: readonly AppSourceMapEntry[];
1538
+ }
1539
+ /** Stable machine-readable linker diagnostic kinds. */
1540
+ type AppLinkDiagnosticCode = 'missing-module' | 'duplicate-module' | 'duplicate-namespace' | 'duplicate-definition' | 'duplicate-screen' | 'missing-reference' | 'cyclic-reference' | 'invalid-component-definition' | 'invalid-component-invocation';
1541
+ /**
1542
+ * A deterministic linker failure with the exact source span that caused it.
1543
+ * @public
1544
+ */
1545
+ interface AppLinkDiagnostic {
1546
+ code: AppLinkDiagnosticCode;
1547
+ message: string;
1548
+ source: AppSourceSpan;
1549
+ }
1550
+ type AppLinkResult = {
1551
+ ok: true;
1552
+ document: AppDocument;
1553
+ diagnostics: readonly [];
1554
+ } | {
1555
+ ok: false;
1556
+ document: null;
1557
+ diagnostics: readonly AppLinkDiagnostic[];
1558
+ };
1559
+
1560
+ /**
1561
+ * Create the stable identity used by linked documents and source maps.
1562
+ * Each segment is encoded so punctuation in authored identifiers cannot collide.
1563
+ *
1564
+ * @public
1565
+ */
1566
+ declare function createAppNodeId(namespace: string, kind: AppNodeKind, id: string): AppNodeId;
1567
+ /** Create the stable identity of an invocation from its owner and structural path. */
1568
+ declare function createAppComponentInstanceId(ownerId: AppNodeId, targetId: AppNodeId, path: readonly number[]): AppComponentInstanceId;
1569
+ /**
1570
+ * Link parsed Wireweave modules into one dependency-closed application document.
1571
+ * The function is pure and returns no document whenever validation finds an error.
1572
+ *
1573
+ * @public
1574
+ * @example
1575
+ * `const result = linkApp(manifest, modules)`
1576
+ */
1577
+ declare function linkApp(manifest: AppManifest, modules: readonly AppModuleInput[]): AppLinkResult;
1578
+
1579
+ /**
1580
+ * Options for {@link compileApp}.
1581
+ *
1582
+ * Application artifacts always use neutral annotation styling. The option is
1583
+ * intentionally omitted here so every compiler caller gets the same wireframe
1584
+ * presentation while legacy render entry points keep their historical default.
1585
+ *
1586
+ * @public
1587
+ */
1588
+ type CompileAppOptions = Omit<SiteOptions, 'annotationStyle'>;
1589
+ /** Result of linking modules and compiling the resulting application. @public */
1590
+ type AppCompileResult = {
1591
+ ok: true;
1592
+ document: AppDocument;
1593
+ html: string;
1594
+ diagnostics: readonly [];
1595
+ } | {
1596
+ ok: false;
1597
+ document: null;
1598
+ html: null;
1599
+ diagnostics: readonly AppLinkDiagnostic[];
1600
+ };
1601
+ /**
1602
+ * Compile one linked application into a deterministic, self-contained HTML document.
1603
+ *
1604
+ * The linker has already expanded component invocations and resolved shared
1605
+ * layouts. This function only projects those resolved nodes into the generic
1606
+ * site compositor, using stable app identities for layout names so modules
1607
+ * cannot collide.
1608
+ *
1609
+ * @public
1610
+ * @example
1611
+ * `const html = compileApp(linked.document)`
1612
+ */
1613
+ declare function compileApp(document: AppDocument, options?: CompileAppOptions): string;
1614
+ /**
1615
+ * Link application modules and compile them when linking succeeds.
1616
+ *
1617
+ * Linker diagnostics remain explicit and no partial HTML is emitted on failure.
1618
+ *
1619
+ * @public
1620
+ * @example
1621
+ * `const result = linkAndCompileApp(manifest, modules)`
1622
+ */
1623
+ declare function linkAndCompileApp(manifest: AppManifest, modules: readonly AppModuleInput[], options?: CompileAppOptions): AppCompileResult;
1624
+
1625
+ export { ANCHOR_LOC_ATTR, ANCHOR_PATH_ATTR, type AccessibilityMetrics, AccordionNode, AlertNode, type AnalysisOptions, type AnalysisResult, type AnchorEntry, AnyNode, type AppCompileResult, type AppComponentInput, type AppComponentInstanceId, type AppDefinitionKind, type AppDocument, type AppLayoutInput, type AppLinkDiagnostic, type AppLinkDiagnosticCode, type AppLinkResult, type AppManifest, type AppManifestModule, type AppModuleInput, type AppNodeId, type AppNodeKind, type AppReferenceInput, type AppScreenInput, type AppSourceMapEntry, type AppSourceSpan, type AttributeChange, AvatarNode, BadgeNode, BreadcrumbNode, ButtonNode, CardNode, CheckboxNode, ColNode, type CompileAppOptions, type ComplexityMetrics, ComponentCategory, ComponentDefinitionNode, type ComponentStats, ComponentUseNode, ContainerComponentNode, ContainerNode, type ContentAnalysis, DEFAULT_VIEWPORT, DEVICE_PRESETS, DataNode, DefinitionNode, type DiffChangeType, type DiffOptions, type DiffResult, type DiffSummary, DisplayNode, DividerComponentNode, type DomTreeNode, DrawerNode, DropdownNode, type ExportOptions, FeedbackNode, type FigmaAutoLayout, type FigmaColor, type FigmaCounterAxisAlign, type FigmaExportResult, type FigmaLayoutMode, type FigmaNode, type FigmaNodeType, type FigmaPrimaryAxisAlign, type FigmaSize, type FigmaSizingMode, type FigmaSolidFill, type FigmaStroke, type FigmaTextAlign, type FigmaTextStyle, FooterNode, GridNode, HeaderNode, IconNode, ImageNode, InputComponentNode, InputNode, InputType, type InteractionDiagnostic, type InteractionDiagnosticCode, InteractionEffect, type InteractionKind, type InteractionModel, type JsonExportResult, type JsonNode, type LayoutAnalysis, LayoutDefinitionNode, LayoutNode, LeafNode, LinkNode, ListNode, MainNode, ModalNode, NavNode, NavigationNode, type NodeChange, type NodePredicate, NodeType, type NormalizedInteraction, type NormalizedInteractionEffect, type NormalizedInteractionHandler, OverlayNode, PageNode, PlaceholderNode, PopoverNode, type PreviewWrapperOptions, ProgressNode, RadioNode, type ResolvedAppComponent, type ResolvedAppLayout, type ResolvedAppModule, type ResolvedAppReference, type ResolvedAppScreen, RowNode, type ScreenAction, type ScreenDisplay, type ScreenElement, type ScreenFields, type ScreenFieldsSummary, type ScreenInput, type ScreenTransitionGraph, SectionNode, SelectNode, SidebarNode, SiteOptions, SliderNode, SlotNode, SourceLocation, type SourceSlice, SpinnerNode, StateDeclaration, StateGuard, SwitchNode, TableNode, TabsNode, TextContentNode, TextNode, TextareaNode, TitleNode, ToastNode, TooltipNode, type TransitionEdge, type TransitionScreen, type TreeMetrics, type ValidationError, type ValidationOptions, type ValidationResult, type ViewportSize, type WalkCallback, WireframeDocument, analyze, areIdentical, buildAnchorIndex, buildDomTree, calculateViewportScale, cloneNode, collectInteractions, compileApp, contains, countNodes, createAppComponentInstanceId, createAppNodeId, diff, documentDefinitions, documentPages, exportToFigma, exportToFigmaString, exportToJson, exportToJsonString, extractAllScreenFields, extractScreenFields, extractScreenTransitions, find, findAll, findByType, formatWireframeCode, getAncestors, getChangeSummary, getDevicePresets, getMaxDepth, getNodeSource, getNodeTypes, getPageSource, getValidationErrors, hasChildren, importFromJson, interactionSignature, isAccordionNode, isAlertNode, isAvatarNode, isBadgeNode, isBreadcrumbNode, isButtonNode, isCardNode, isCheckboxNode, isColNode, isComponentDefinitionNode, isComponentUseNode, isContainerComponentNode, isContainerNode, isDataNode, isDefinitionNode, isDisplayNode, isDividerNode, isDrawerNode, isDropdownNode, isFeedbackNode, isFooterNode, isGridNode, isHeaderNode, isIconNode, isImageNode, isInputComponentNode, isInputNode, isLayoutDefinitionNode, isLayoutNode, isLeafNode, isLinkNode, isListNode, isMainNode, isModalNode, isNavNode, isNavigationNode, isNodeType, isOverlayNode, isPageNode, isPlaceholderNode, isPopoverNode, isProgressNode, isRadioNode, isRowNode, isSectionNode, isSelectNode, isSidebarNode, isSliderNode, isSlotNode, isSpinnerNode, isSwitchNode, isTableNode, isTabsNode, isTextContentNode, isTextNode, isTextareaNode, isTitleNode, isToastNode, isTooltipNode, isUrlTarget, isValidAst, isValidDevicePreset, linkAndCompileApp, linkApp, mapNodes, normalizeInteractionHandlers, normalizeStateGuard, parseViewportString, printWireframe, resetFigmaIdCounter, resolveAnchor, resolveViewport, validate, walk, walkDocument, wrapInPreviewContainer };