nudge-ui 0.2.4 → 0.2.6

package/dist/compiler/ast.d.ts

@@ -1,18 +1,12 @@
-/** The subset of Babel nodes needed by the host-neutral compiler. */
 export type SyntaxNode = {
     type: string;
     [key: string]: unknown;
 };
-/** Node keys that never hold children worth visiting. */
 export declare const SKIP_KEYS: Set<string>;
 export declare function isNode(value: unknown): value is SyntaxNode;
-/** Visit every child node with the property name it was reached through. */
 export declare function forEachChild(node: SyntaxNode, visit: (child: SyntaxNode, key: string) => void): void;
 export declare function childNodes(node: SyntaxNode): SyntaxNode[];
 export declare function identifier(node: unknown): string | null;
-/** Dotted name for a JSX element name: `A`, `A.B`, `A.B.C`. */
 export declare function jsxMemberName(node: unknown): string | null;
-/** Dotted name for an identifier expression or a JSX element name. */
 export declare function elementName(node: unknown): string | null;
-/** Parse module source, returning `null` when the source is not parseable. */
 export declare function parseModule(code: string): SyntaxNode | null;

package/dist/compiler/ast.js

@@ -1,5 +1,4 @@
 import { parse } from "@babel/parser";
-/** Node keys that never hold children worth visiting. */
 export const SKIP_KEYS = new Set([
     "type",
     "loc",
@@ -14,7 +13,6 @@ export const SKIP_KEYS = new Set([
 export function isNode(value) {
     return typeof value === "object" && value !== null && typeof Reflect.get(value, "type") === "string";
 }
-/** Visit every child node with the property name it was reached through. */
 export function forEachChild(node, visit) {
     for (const [key, value] of Object.entries(node)) {
         if (SKIP_KEYS.has(key))
@@ -41,7 +39,6 @@ export function identifier(node) {
         return null;
     return typeof node.name === "string" ? node.name : typeof node.value === "string" ? node.value : null;
 }
-/** Dotted name for a JSX element name: `A`, `A.B`, `A.B.C`. */
 export function jsxMemberName(node) {
     if (!isNode(node))
         return null;
@@ -53,7 +50,6 @@ export function jsxMemberName(node) {
     const property = jsxMemberName(node.property);
     return object && property ? `${object}.${property}` : null;
 }
-/** Dotted name for an identifier expression or a JSX element name. */
 export function elementName(node) {
     if (!isNode(node))
         return null;
@@ -61,7 +57,6 @@ export function elementName(node) {
         return typeof node.name === "string" ? node.name : null;
     return jsxMemberName(node);
 }
-/** Parse module source, returning `null` when the source is not parseable. */
 export function parseModule(code) {
     try {
         return parse(code, {

package/dist/compiler/componentContractTypes.d.ts

@@ -1,11 +1,6 @@
 export type ComponentPropValue = string | number | boolean;
 export interface ComponentPropContract {
     name: string;
-    /**
-     * `text` is deliberately separate from a select. Text edits are allowed to
-     * choose an arbitrary string at runtime, while select controls are bounded
-     * by their contract options.
-     */
     control: "select" | "boolean" | "text";
     options: ComponentPropValue[];
     optional: boolean;
@@ -17,3 +12,14 @@ export interface ComponentContract {
     props: ComponentPropContract[];
     provenance: "typescript" | "package-manifest";
 }
+/** How a prop was written at its callsite; `default` exists only at runtime, for omitted props. */
+export type AuthoredInvocationPropKind = "literal" | "expression" | "spread";
+export interface ComponentInvocationMeta {
+    callsiteId: string;
+    componentId: string;
+    componentName: string;
+    file: string;
+    line: number;
+    column: number;
+    authoredProps: Record<string, AuthoredInvocationPropKind>;
+}

package/dist/compiler/componentContracts.js

@@ -1,4 +1,5 @@
 import { parse } from "@babel/parser";
+import { componentIdentity } from "./sourcePaths.js";
 function isNode(value) {
     return typeof value === "object"
         && value !== null
@@ -41,11 +42,6 @@ function literalValue(node) {
     }
     return null;
 }
-/**
- * These are the names that a component contract can confidently describe as
- * visible copy. The runtime still requires the current value to be a string
- * equal to the rendered text before offering an inline binding.
- */
 const STRUCTURAL_TEXT_PROPS = new Set([
     "id",
     "className",
@@ -75,9 +71,7 @@ function propertyContract(member) {
     const typeNode = unwrapTypeAnnotation(member.typeAnnotation);
     if (!name || !typeNode)
         return null;
-    // Project contracts recognize all runtime string props. Structural and
-    // implementation names are excluded here; package manifests can still
-    // explicitly publish a text control for a project-specific visible prop.
+    // Structural names are excluded from text controls here; package manifests can still publish them explicitly.
     if (!isStructuralTextProp(name) && isTextType(typeNode)) {
         return {
             name,
@@ -190,7 +184,7 @@ function componentContract(name, propsType, declarations, file) {
     if (props.length === 0)
         return null;
     return {
-        componentId: `${file.replace(/\.(?:d\.)?[cm]?[jt]sx?$/, "")}#${name}`,
+        componentId: componentIdentity(file, name),
         name,
         file,
         props,

package/dist/compiler/componentInstrumentation.d.ts

@@ -1,15 +1,8 @@
 import { type SyntaxNode } from "./ast.js";
 export type { SyntaxNode } from "./ast.js";
 export interface ComponentInstrumentationOptions {
-    /**
-     * Package exports whose element type can be replaced by a semantic preview
-     * wrapper. Keys are exact import specifiers; values are exported names
-     * (`default` for a default import). Discovery of a prop contract does not
-     * imply compatibility. Prefer `hostPolicy` when the host can resolve import
-     * provenance and rendered slots.
-     */
+    /** Exact specifier → exported names (`default` for a default import); a discovered contract alone never opts in. */
     compatibleComponentImports?: Readonly<Record<string, readonly string[]>>;
-    /** Data-only import provenance and slot semantics resolved by the host Adapter. */
     hostPolicy?: import("./componentPolicyResolution.js").HostComponentPolicy;
 }
 export interface ComponentBinding {
@@ -24,9 +17,5 @@ export interface ComponentInstrumentationPolicy {
     rendersProp(componentName: string, prop: string): boolean;
     componentId(componentName: string): string | null;
 }
-/**
- * Classify bindings before editing JSX. Unknown and shadowed bindings are
- * deliberately excluded: losing a semantic control is safer than changing an
- * application's component protocol. Rendered DOM identity is independent.
- */
+/** Unknown and shadowed bindings are deliberately excluded: losing a semantic control beats altering an app's protocol. */
 export declare function createComponentInstrumentationPolicy(ast: SyntaxNode, options: ComponentInstrumentationOptions): ComponentInstrumentationPolicy;

package/dist/compiler/componentInstrumentation.js

@@ -1,9 +1,5 @@
 import { childNodes, identifier, isNode } from "./ast.js";
-/**
- * Classify bindings before editing JSX. Unknown and shadowed bindings are
- * deliberately excluded: losing a semantic control is safer than changing an
- * application's component protocol. Rendered DOM identity is independent.
- */
+/** Unknown and shadowed bindings are deliberately excluded: losing a semantic control beats altering an app's protocol. */
 export function createComponentInstrumentationPolicy(ast, options) {
     const bindings = new Map();
     const locals = new Set();
@@ -100,9 +96,7 @@ export function createComponentInstrumentationPolicy(ast, options) {
         childNodes(node).forEach(visit);
     };
     visit(program);
-    // A definition authored in this module is project-owned by construction: no
-    // host resolution applies, and its JSX children are authored here rather
-    // than handed to an opaque third-party interface.
+    // Authored in this module, so its JSX children are not handed to an opaque third-party interface.
     const isProjectLocalComponent = (componentName) => {
         const [root, ...members] = componentName.split(".");
         if (!root || ambiguous.has(root))
@@ -118,10 +112,7 @@ export function createComponentInstrumentationPolicy(ast, options) {
             const resolved = options.hostPolicy?.components[componentName];
             if (resolved)
                 return resolved.wrap;
-            // No host policy: this is the direct-compiler path, where a package
-            // export is only compatible when the caller names it explicitly. The
-            // host-resolved policy traces re-exports and namespace members, so this
-            // fallback deliberately matches on the authored import alone.
+            // Direct-compiler fallback: matches the authored import alone, unlike host resolution which traces re-exports.
             return options.compatibleComponentImports?.[binding.source]?.includes(binding.exportName) === true;
         },
         rendersChildren(componentName) {

package/dist/compiler/componentPolicyResolution.d.ts

@@ -1,15 +1,9 @@
 /** Whether replacing a JSX element type with the semantic boundary is safe. */
 export interface ComponentProtocol {
     readonly wrap: boolean;
-    /**
-     * JSX-valued slots where the compiler may apply each descendant's resolved
-     * protocol. A component that resolves to project-owned source defaults to
-     * `wrap: true` with `children: "rendered"`; every other slot stays opaque
-     * until a host declares it.
-     */
+    /** JSX-valued slots descendants may be instrumented through; undeclared slots stay opaque. */
     readonly slots?: Readonly<Record<string, "rendered" | "opaque">>;
 }
-/** Component protocols exported by one canonical module specifier. */
 export interface ComponentModuleProtocol {
     readonly default?: ComponentProtocol;
     readonly exports?: Readonly<Record<string, ComponentProtocol>>;
@@ -17,7 +11,6 @@ export interface ComponentModuleProtocol {
 export interface ComponentModuleProtocols {
     readonly [source: string]: ComponentModuleProtocol | undefined;
 }
-/** Build-tool operations needed to resolve an authored import to its defining module. */
 export interface ComponentModuleAdapter {
     resolve(specifier: string, importer: string): Promise<string | null>;
     read(id: string): Promise<string | null>;
@@ -35,7 +28,6 @@ export interface ComponentPolicyDiagnostic {
     readonly source: string;
     readonly exportName: string;
 }
-/** Data-only policy consumed by the source compiler after a host resolves imports. */
 export interface HostComponentPolicy {
     readonly components: Readonly<Record<string, ResolvedComponentProtocol>>;
     readonly diagnostics: readonly ComponentPolicyDiagnostic[];
@@ -45,16 +37,9 @@ export interface ResolveHostComponentPolicyOptions {
     /** Backwards-compatible shorthand: these exports may be wrapped but expose no rendered slots. */
     readonly compatibleComponentImports?: Readonly<Record<string, readonly string[]>>;
 }
-/** Merge a host's protocol additions over a shared compatibility catalog. */
 export declare function mergeComponentModuleProtocols(defaults: ComponentModuleProtocols, overrides: ComponentModuleProtocols | undefined): ComponentModuleProtocols;
-/**
- * Resolve the imported JSX values used by one source file.
- *
- * The compiler owns syntax and re-export traversal. The host Adapter owns all
- * build-tool resolution, source ownership, and stable path decisions.
- */
+/** The compiler owns syntax and re-export traversal; the host Adapter owns build-tool resolution and path decisions. */
 export declare function resolveHostComponentPolicy(code: string, importer: string, adapter: ComponentModuleAdapter, options?: ResolveHostComponentPolicyOptions): Promise<HostComponentPolicy>;
-/** One actionable message per diagnostic code and source. */
 export interface GroupedComponentPolicyDiagnostic {
     /** Stable dedupe key for host-side "warn once" tracking. */
     readonly key: string;
@@ -62,10 +47,6 @@ export interface GroupedComponentPolicyDiagnostic {
     readonly componentNames: readonly string[];
     readonly total: number;
 }
-/**
- * Roll per-component diagnostics up so a host emits one warning per package
- * instead of one per skipped export.
- */
+/** Rolls per-component diagnostics up so a host warns once per package, not once per skipped export. */
 export declare function groupComponentPolicyDiagnostics(diagnostics: readonly ComponentPolicyDiagnostic[], maxNames?: number): GroupedComponentPolicyDiagnostic[];
-/** Host-facing warning text for one grouped diagnostic. */
 export declare function formatComponentPolicyWarning(grouped: GroupedComponentPolicyDiagnostic, location: string, hint?: string): string;

package/dist/compiler/componentPolicyResolution.js

@@ -1,6 +1,5 @@
 import { childNodes, identifier, isNode, jsxMemberName, parseModule, } from "./ast.js";
-import { stripModuleExtension } from "./sourcePaths.js";
-/** Merge a host's protocol additions over a shared compatibility catalog. */
+import { componentIdentity, stripModuleExtension } from "./sourcePaths.js";
 export function mergeComponentModuleProtocols(defaults, overrides) {
     if (!overrides)
         return defaults;
@@ -20,18 +19,11 @@ export function mergeComponentModuleProtocols(defaults, overrides) {
     }
     return merged;
 }
-/** A resolution failure that carries only the reason a host reports. */
 function unresolved(code) {
     return { resolved: false, code };
 }
 const MAX_REEXPORT_DEPTH = 24;
-/**
- * Analyses are a pure function of module source, so a content-addressed cache
- * is correct across HMR without host-specific invalidation: an edited file
- * simply misses and is re-analysed, while every unchanged re-export target
- * skips its parse. Without this, policy resolution reparses every reachable
- * module on every transform.
- */
+/** Keyed by module source, so the cache is correct across HMR without host-specific invalidation. */
 const ANALYSIS_CACHE_LIMIT = 128;
 const analysisCache = new Map();
 function analyseModuleSource(code) {
@@ -48,12 +40,7 @@ function analyseModuleSource(code) {
     analysisCache.set(code, analysis);
     return analysis;
 }
-/**
- * Resolve the imported JSX values used by one source file.
- *
- * The compiler owns syntax and re-export traversal. The host Adapter owns all
- * build-tool resolution, source ownership, and stable path decisions.
- */
+/** The compiler owns syntax and re-export traversal; the host Adapter owns build-tool resolution and path decisions. */
 export async function resolveHostComponentPolicy(code, importer, adapter, options = {}) {
     const analysis = analyseModuleSource(code);
     if (!analysis) {
@@ -80,7 +67,6 @@ export async function resolveHostComponentPolicy(code, importer, adapter, option
     }
     return { components, diagnostics };
 }
-/** Depth-first pre-order traversal of every node in a tree. */
 function visit(node, callback) {
     callback(node);
     for (const child of childNodes(node))
@@ -209,12 +195,6 @@ function importedReference(componentName, imports) {
         return null;
     return { source: binding.source, exportName };
 }
-/**
- * Trace authored imports to the protocol of the component they name.
- *
- * The tracer closes over the host Adapter and the protocol catalog, so each
- * step carries only its request, the module it sits in, and its trace state.
- */
 function createTracer(adapter, options) {
     async function request(source, exportName, importer, state) {
         const declared = declaredProtocol(source, exportName, options);
@@ -291,7 +271,6 @@ function createTracer(adapter, options) {
         return request(reference.source, reference.exportName, module.moduleId, state);
     }
     return {
-        /** Resolve one authored import to the protocol of the component it names. */
         request: (source, exportName, importer) => request(source, exportName, importer, { visited: new Set(), depth: 0 }),
     };
 }
@@ -341,25 +320,15 @@ function resolvedProtocol(source, exportName, protocol) {
         resolved: true,
         protocol: {
             ...protocol,
-            componentId: `${stripModuleExtension(source)}#${exportName}`,
+            componentId: componentIdentity(source, exportName),
         },
     };
 }
-/**
- * Default protocol for a component that resolves to project-owned source.
- *
- * The inspected codebase owns the definition, so replacing the element type is
- * safe and its authored `children` may be traversed. Named JSX props stay
- * opaque: only a host-declared protocol can promise that a named slot renders
- * its contents.
- */
+/** Project-owned source is safe to wrap, but named JSX props stay opaque until a host promises they render. */
 function projectProtocol(source, exportName) {
     return resolvedProtocol(source, exportName, { wrap: true, slots: { children: "rendered" } });
 }
-/**
- * Roll per-component diagnostics up so a host emits one warning per package
- * instead of one per skipped export.
- */
+/** Rolls per-component diagnostics up so a host warns once per package, not once per skipped export. */
 export function groupComponentPolicyDiagnostics(diagnostics, maxNames = 5) {
     const groups = new Map();
     for (const diagnostic of diagnostics) {
@@ -377,7 +346,6 @@ export function groupComponentPolicyDiagnostics(diagnostics, maxNames = 5) {
         total: group.length,
     }));
 }
-/** Host-facing warning text for one grouped diagnostic. */
 export function formatComponentPolicyWarning(grouped, location, hint = "Add componentProtocols metadata to opt in compatible package exports.") {
     const names = grouped.componentNames.join(", ");
     const remainder = grouped.total > grouped.componentNames.length

package/dist/compiler/identityAttributes.d.ts

@@ -0,0 +1,2 @@
+/** Compiler-injected attributes the runtime also reads back from component props. */
+export declare const IDENTITY_ATTRIBUTES: readonly ["data-cid", "data-src", "data-cprops"];

package/dist/compiler/identityAttributes.js

@@ -0,0 +1,2 @@
+/** Compiler-injected attributes the runtime also reads back from component props. */
+export const IDENTITY_ATTRIBUTES = ["data-cid", "data-src", "data-cprops"];

package/dist/compiler/index.d.ts

@@ -1,4 +1,3 @@
-/** Host-neutral source compilers used by framework adapters. */
 export * from "./reactIdentity.js";
 export * from "./componentInstrumentation.js";
 export * from "./componentPolicyResolution.js";

package/dist/compiler/index.js

@@ -1,4 +1,3 @@
-/** Host-neutral source compilers used by framework adapters. */
 export * from "./reactIdentity.js";
 export * from "./componentInstrumentation.js";
 export * from "./componentPolicyResolution.js";

package/dist/compiler/packageComponentContracts.d.ts

@@ -1,32 +1,23 @@
 import ts from "typescript";
 import type { ComponentContract } from "./componentContractTypes.js";
-/**
- * Identifies a package import from the host module that uses it.
- *
- * The host path is intentional: TypeScript uses it as the resolution anchor,
- * so the same module specifier can resolve to a different installed package in
- * each application. The returned contract identity always uses the import
- * specifier, never an absolute node_modules path.
- */
+/** hostFile is the resolution anchor; contract identity uses the specifier, never an absolute node_modules path. */
 export interface PackageContractContext {
     hostFile: string;
     moduleSpecifier: string;
     compilerOptions?: ts.CompilerOptions;
 }
+export interface PackageComponentImport {
+    readonly moduleSpecifier: string;
+    readonly exportName: string;
+}
 export interface PackageContractCatalogContext {
     hostFile: string;
-    moduleSpecifiers: readonly string[];
+    /** Scoped to what the app renders: the catalog ships to the browser and icon-set packages export thousands. */
+    imports: readonly PackageComponentImport[];
     compilerOptions?: ts.CompilerOptions;
 }
-/** Returns bare modules whose imported bindings are rendered as JSX. */
-export declare function collectPackageComponentModules(code: string, fileName: string): string[];
-/**
- * Extracts scalar controls from component exports in an installed package.
- *
- * It follows TypeScript's resolved module graph, including barrel re-exports
- * and declaration-file aliases, rather than trying to parse one declaration
- * file in isolation.
- */
+export declare function collectPackageComponentImports(code: string, fileName: string): PackageComponentImport[];
+/** Follows TypeScript's resolved module graph (barrel re-exports, declaration aliases), not one file in isolation. */
 export declare function extractPackageComponentContracts(context: PackageContractContext): ComponentContract[];
-/** Extracts several package modules through one declaration-only program. */
+/** Resolves every module through one declaration-only program. */
 export declare function extractPackageComponentContractCatalog(context: PackageContractCatalogContext): ComponentContract[];

package/dist/compiler/packageComponentContracts.js

@@ -1,5 +1,6 @@
 import { dirname, relative, resolve } from "node:path";
 import ts from "typescript";
+import { componentIdentity } from "./sourcePaths.js";
 function isBareModuleSpecifier(value) {
     return value !== ""
         && !value.startsWith(".")
@@ -7,16 +8,18 @@ function isBareModuleSpecifier(value) {
         && !value.startsWith("\0")
         && !value.startsWith("virtual:");
 }
-function rootJsxIdentifier(tagName) {
+function jsxTagReference(tagName) {
+    const members = [];
     let current = tagName;
-    while (ts.isPropertyAccessExpression(current))
+    while (ts.isPropertyAccessExpression(current)) {
+        members.unshift(current.name.text);
         current = current.expression;
-    return ts.isIdentifier(current) ? current.text : null;
+    }
+    return ts.isIdentifier(current) ? { binding: current.text, member: members[0] ?? null } : null;
 }
-/** Returns bare modules whose imported bindings are rendered as JSX. */
-export function collectPackageComponentModules(code, fileName) {
+export function collectPackageComponentImports(code, fileName) {
     const source = ts.createSourceFile(fileName, code, ts.ScriptTarget.Latest, true, fileName.endsWith("x") ? ts.ScriptKind.TSX : ts.ScriptKind.JSX);
-    const modulesByBinding = new Map();
+    const bindings = new Map();
     for (const statement of source.statements) {
         if (!ts.isImportDeclaration(statement)
             || !ts.isStringLiteral(statement.moduleSpecifier)
@@ -24,31 +27,44 @@ export function collectPackageComponentModules(code, fileName) {
             continue;
         const moduleSpecifier = statement.moduleSpecifier.text;
         const clause = statement.importClause;
-        if (clause?.name)
-            modulesByBinding.set(clause.name.text, moduleSpecifier);
-        const bindings = clause?.namedBindings;
-        if (bindings && ts.isNamespaceImport(bindings)) {
-            modulesByBinding.set(bindings.name.text, moduleSpecifier);
+        if (!clause || clause.isTypeOnly)
+            continue;
+        if (clause.name)
+            bindings.set(clause.name.text, { moduleSpecifier, exportName: "default" });
+        const named = clause.namedBindings;
+        if (named && ts.isNamespaceImport(named)) {
+            bindings.set(named.name.text, { moduleSpecifier, exportName: null });
         }
-        else if (bindings && ts.isNamedImports(bindings)) {
-            for (const element of bindings.elements) {
-                if (!element.isTypeOnly)
-                    modulesByBinding.set(element.name.text, moduleSpecifier);
+        else if (named && ts.isNamedImports(named)) {
+            for (const element of named.elements) {
+                if (element.isTypeOnly)
+                    continue;
+                bindings.set(element.name.text, {
+                    moduleSpecifier,
+                    exportName: (element.propertyName ?? element.name).text,
+                });
             }
         }
     }
-    const modules = new Set();
+    const imports = new Map();
     const visit = (node) => {
         if (ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node)) {
-            const binding = rootJsxIdentifier(node.tagName);
-            const moduleSpecifier = binding ? modulesByBinding.get(binding) : undefined;
-            if (moduleSpecifier)
-                modules.add(moduleSpecifier);
+            const reference = jsxTagReference(node.tagName);
+            const binding = reference ? bindings.get(reference.binding) : undefined;
+            const exportName = binding?.exportName ?? reference?.member ?? null;
+            if (binding && exportName) {
+                imports.set(`${binding.moduleSpecifier}#${exportName}`, {
+                    moduleSpecifier: binding.moduleSpecifier,
+                    exportName,
+                });
+            }
         }
         ts.forEachChild(node, visit);
     };
     visit(source);
-    return [...modules].sort();
+    return [...imports]
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([, value]) => value);
 }
 const DEFAULT_COMPILER_OPTIONS = {
     allowJs: false,
@@ -121,10 +137,7 @@ function literalOptions(members, checker, location) {
     const values = members
         .map(literalValue)
         .filter((value) => value !== null);
-    // A public prop can accept a finite scalar vocabulary as well as a
-    // responsive/conditional object. The Inspector only offers this select when
-    // the current runtime value is scalar, so retain valid scalar alternatives
-    // without pretending the object form is itself editable here.
+    // Conditional object forms keep their scalar alternatives valid without making the object itself editable.
     if (values.length < 2)
         return null;
     const primitive = typeof values[0];
@@ -241,34 +254,34 @@ function componentContract(exportName, symbol, checker, packageRoot, moduleSpeci
     if (props.length === 0)
         return null;
     return {
-        componentId: `${moduleSpecifier}#${exportName}`,
+        componentId: componentIdentity(moduleSpecifier, exportName),
         name: exportName,
         file: moduleSpecifier,
         props,
         provenance: "typescript",
     };
 }
-/**
- * Extracts scalar controls from component exports in an installed package.
- *
- * It follows TypeScript's resolved module graph, including barrel re-exports
- * and declaration-file aliases, rather than trying to parse one declaration
- * file in isolation.
- */
+/** Follows TypeScript's resolved module graph (barrel re-exports, declaration aliases), not one file in isolation. */
 export function extractPackageComponentContracts(context) {
-    return extractPackageComponentContractCatalog({
-        hostFile: context.hostFile,
-        moduleSpecifiers: [context.moduleSpecifier],
-        compilerOptions: context.compilerOptions,
-    });
+    return extractContracts(context.hostFile, new Map([[context.moduleSpecifier, null]]), context.compilerOptions);
 }
-/** Extracts several package modules through one declaration-only program. */
+/** Resolves every module through one declaration-only program. */
 export function extractPackageComponentContractCatalog(context) {
-    const compilerOptions = { ...DEFAULT_COMPILER_OPTIONS, ...context.compilerOptions };
-    const moduleSpecifiers = [...new Set(context.moduleSpecifiers)].sort();
+    const exportsByModule = new Map();
+    for (const { moduleSpecifier, exportName } of context.imports) {
+        const exportNames = exportsByModule.get(moduleSpecifier) ?? new Set();
+        exportNames.add(exportName);
+        exportsByModule.set(moduleSpecifier, exportNames);
+    }
+    return extractContracts(context.hostFile, exportsByModule, context.compilerOptions);
+}
+/** `null` export names describe every export of that module. */
+function extractContracts(hostFile, exportsByModule, overrides) {
+    const compilerOptions = { ...DEFAULT_COMPILER_OPTIONS, ...overrides };
+    const moduleSpecifiers = [...exportsByModule.keys()].sort();
     if (moduleSpecifiers.length === 0)
         return [];
-    const virtualFile = resolve(dirname(context.hostFile), "__nudge_ui_package_contracts__.tsx");
+    const virtualFile = resolve(dirname(hostFile), "__nudge_ui_package_contracts__.tsx");
     const virtualSource = moduleSpecifiers
         .map((moduleSpecifier, index) => `import * as __nudgeUiPackage${index} from ${JSON.stringify(moduleSpecifier)};`)
         .join("\n");
@@ -296,7 +309,11 @@ export function extractPackageComponentContractCatalog(context) {
         if (!moduleSymbol)
             return [];
         const packageRoot = packageRootFor(resolution.resolvedFileName, moduleSpecifier);
-        return checker.getExportsOfModule(moduleSymbol)
+        const exportNames = exportsByModule.get(moduleSpecifier);
+        const symbols = exportNames
+            ? [...exportNames].sort().flatMap((exportName) => checker.tryGetMemberInModuleExports(exportName, moduleSymbol) ?? [])
+            : checker.getExportsOfModule(moduleSymbol);
+        return symbols
             .map((symbol) => {
             const exportName = symbolName(symbol);
             return exportName

package/dist/compiler/reactComponentProtocols.d.ts

@@ -1,10 +1,3 @@
-/**
- * Adapter-independent React compatibility data.
- *
- * Library names live in this replaceable catalog rather than in compiler
- * control flow. Hosts may extend or replace these facts as their ecosystem
- * support grows.
- */
 export declare const defaultReactComponentProtocols: {
     react: {
         default: {

package/dist/compiler/reactComponentProtocols.js

@@ -1,12 +1,5 @@
 const PRESERVE = { wrap: false };
 const RENDERED_CHILDREN = { wrap: false, slots: { children: "rendered" } };
-/**
- * Adapter-independent React compatibility data.
- *
- * Library names live in this replaceable catalog rather than in compiler
- * control flow. Hosts may extend or replace these facts as their ecosystem
- * support grows.
- */
 export const defaultReactComponentProtocols = {
     react: {
         default: PRESERVE,

package/dist/compiler/reactIdentity.d.ts

@@ -4,12 +4,12 @@ export type { ComponentInstrumentationOptions } from "./componentInstrumentation
 export interface InjectResult {
     code: string;
     map: SourceMap | null;
+    /** The exact single line prepended to bind the runtime, or null; hosts with a directive prologue relocate it. */
+    prelude: string | null;
 }
 export interface InjectIdentityOptions extends ComponentInstrumentationOptions {
     instrumentComponents?: boolean;
-    /** Module specifier emitted for the host-owned semantic runtime. */
     componentRuntimeModule?: string;
 }
 export declare const DEFAULT_COMPONENT_RUNTIME_MODULE = "nudge-ui/internal/component-runtime";
 export declare function injectIdentity(code: string, id: string, root?: string, options?: InjectIdentityOptions): InjectResult | null;
-export declare function injectDataCid(code: string, id: string, root?: string): InjectResult | null;