pupt-lib 1.3.0 → 1.3.2

package/dist/src/component.d.ts

@@ -0,0 +1,112 @@
+import { ZodObject, ZodRawShape } from 'zod';
+import { PuptNode, RenderContext } from './types';
+import { LlmProvider } from './types/context';
+/**
+ * Symbol used to mark Component classes for identification
+ */
+export declare const COMPONENT_MARKER: unique symbol;
+/**
+ * Abstract base class for pupt-lib components.
+ * Extend this class to create class-based components with access to render context.
+ *
+ * Components can implement:
+ * - `resolve()` only: Compute a value (rendered as string, no visual output)
+ * - `render()` only: Produce visual output (backward compatible)
+ * - Both `resolve()` and `render()`: Compute value, then render with that value
+ *
+ * Both resolve and render methods can be synchronous or asynchronous.
+ *
+ * @example
+ * ```typescript
+ * // Component with resolve() only - value is stringified
+ * class ValueComponent extends Component<{ value: string }, string> {
+ *   resolve(props: { value: string }) {
+ *     return props.value.toUpperCase();
+ *   }
+ * }
+ *
+ * // Component with only render() (backward compatible)
+ * class Greeting extends Component<{ name: string }> {
+ *   render(props: { name: string }) {
+ *     return `Hello, ${props.name}!`;
+ *   }
+ * }
+ *
+ * // Component with both resolve() and render()
+ * class DataFetcher extends Component<{ id: number }, { data: string }> {
+ *   resolve(props: { id: number }) {
+ *     return { data: `Data for ${props.id}` };
+ *   }
+ *   render(props: { id: number }, value: { data: string }) {
+ *     return `Fetched: ${value.data}`;
+ *   }
+ * }
+ * ```
+ */
+export declare abstract class Component<Props = Record<string, unknown>, ResolveType = void> {
+    static [COMPONENT_MARKER]: boolean;
+    /** Zod schema for validating component props (excluding children) */
+    static schema: ZodObject<ZodRawShape>;
+    /** Optional Zod schema for validating the resolved value */
+    static resolveSchema?: ZodObject<ZodRawShape>;
+    /**
+     * When true, the name-hoisting Babel plugin will hoist this component's
+     * `name` prop to a variable declaration. Components that use `name` for
+     * variable creation (e.g., File, ReviewFile) should set this to true.
+     * Components that use `name` for identification (e.g., Section, Role)
+     * leave this unset.
+     */
+    static hoistName?: boolean;
+    /**
+     * Optional: Compute the resolved value for this component.
+     *
+     * If implemented, this method is called before render().
+     * The resolved value is stored and can be passed to other components.
+     *
+     * @param props - The properties passed to the component
+     * @param context - The render context containing environment and inputs
+     * @returns The resolved value, or a Promise resolving to the value for async components
+     */
+    resolve?(props: Props, context: RenderContext): ResolveType | Promise<ResolveType>;
+    /**
+     * Get the LLM provider from the render context.
+     *
+     * @param context - The render context
+     * @returns The LLM provider string
+     */
+    protected getProvider(context: RenderContext): LlmProvider;
+    /**
+     * Get the appropriate delimiter based on the output format in the render context.
+     * Returns 'markdown' if the output format is markdown, otherwise 'xml'.
+     *
+     * @param context - The render context
+     * @returns The delimiter style to use
+     */
+    protected getDelimiter(context: RenderContext): 'xml' | 'markdown' | 'none';
+    /**
+     * Check if children has meaningful content.
+     * Returns false for undefined, null, empty arrays, and empty strings.
+     */
+    protected hasContent(children: PuptNode): boolean;
+    /**
+     * Optional: Render the component with the given props and resolved value.
+     *
+     * If the component has a resolve() method, the resolved value is passed as the
+     * second argument. For backward compatibility, components without resolve() will
+     * receive undefined as the resolved value.
+     *
+     * @param props - The properties passed to the component
+     * @param resolvedValue - The value returned by resolve(), or undefined if no resolve() method
+     * @param context - The render context containing environment and inputs
+     * @returns The rendered output as a PuptNode, or a Promise resolving to a PuptNode for async components
+     */
+    render?(props: Props, resolvedValue: ResolveType, context: RenderContext): PuptNode | Promise<PuptNode>;
+}
+/**
+ * Type guard to check if a value is a Component class (not an instance).
+ *
+ * @param value - The value to check
+ * @returns true if the value is a class extending Component
+ */
+export declare function isComponentClass(value: unknown): value is typeof Component;
+//# sourceMappingURL=component.d.ts.map

package/dist/src/component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component.d.ts","sourceRoot":"","sources":["../../src/component.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,KAAK,CAAC;AAClD,OAAO,KAAK,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AACvD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnD;;GAEG;AACH,eAAO,MAAM,gBAAgB,eAAsC,CAAC;AAEpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,8BAAsB,SAAS,CAC7B,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,WAAW,GAAG,IAAI;IAElB,MAAM,CAAC,CAAC,gBAAgB,CAAC,UAAQ;IAEjC,qEAAqE;IACrE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,WAAW,CAAC,CAAC;IAEtC,4DAA4D;IAC5D,MAAM,CAAC,aAAa,CAAC,EAAE,SAAS,CAAC,WAAW,CAAC,CAAC;IAE9C;;;;;;OAMG;IACH,MAAM,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;IAE3B;;;;;;;;;OASG;IACH,OAAO,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,aAAa,GAAG,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;IAElF;;;;;OAKG;IACH,SAAS,CAAC,WAAW,CAAC,OAAO,EAAE,aAAa,GAAG,WAAW;IAI1D;;;;;;OAMG;IACH,SAAS,CAAC,YAAY,CAAC,OAAO,EAAE,aAAa,GAAG,KAAK,GAAG,UAAU,GAAG,MAAM;IAI3E;;;OAGG;IACH,SAAS,CAAC,UAAU,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO;IASjD;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,OAAO,EAAE,aAAa,GAAG,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;CACxG;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,OAAO,SAAS,CAK3B"}

package/dist/src/create-prompt.d.ts

@@ -0,0 +1,118 @@
+import { PuptElement, ComponentType } from './types';
+/**
+ * Custom component registration for browser environments.
+ *
+ * In browser environments, dynamically evaluated code can only import from URLs
+ * that the import map knows about. For custom components that aren't published
+ * to npm, you can pass them here and reference them by name in your source.
+ *
+ * @example
+ * ```typescript
+ * const element = await createPromptFromSource(source, 'test.prompt', {
+ *   components: {
+ *     MyHeader: MyHeaderComponent,
+ *     CustomCard: CustomCardComponent,
+ *   }
+ * });
+ * ```
+ *
+ * Then in your source:
+ * ```tsx
+ * <Prompt name="test">
+ *   <MyHeader>Title</MyHeader>
+ *   <CustomCard>Content</CustomCard>
+ * </Prompt>
+ * ```
+ */
+export interface CreatePromptOptions {
+    /**
+     * Custom components to make available in the evaluated source.
+     * Keys are component names, values are component classes.
+     *
+     * In browser environments, this is the primary way to use custom components
+     * that aren't published to npm.
+     */
+    components?: Record<string, ComponentType>;
+}
+/**
+ * Global key used for injecting custom components.
+ * @internal
+ */
+export declare const CUSTOM_COMPONENTS_GLOBAL = "__PUPT_CUSTOM_COMPONENTS__";
+/**
+ * Declare the global type for TypeScript
+ */
+declare global {
+    var __PUPT_CUSTOM_COMPONENTS__: Record<string, ComponentType> | undefined;
+}
+/**
+ * Create a PuptElement from a TSX source string.
+ * Transforms the JSX and evaluates it to produce an element tree.
+ *
+ * For .prompt files or raw JSX without imports, built-in component imports
+ * are automatically injected.
+ *
+ * For .tsx files with imports, the source is used as-is.
+ *
+ * @param source - TSX source code
+ * @param filename - Filename for error messages and source maps
+ * @param options - Optional configuration
+ * @returns The default export as a PuptElement
+ *
+ * @example
+ * ```typescript
+ * // .tsx file with imports
+ * const source = `
+ *   import { Prompt, Role } from 'pupt-lib';
+ *   export default (
+ *     <Prompt name="test">
+ *       <Role>Assistant</Role>
+ *     </Prompt>
+ *   );
+ * `;
+ * const element = await createPromptFromSource(source, 'test.tsx');
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // .prompt file (auto-imports built-in components)
+ * const source = `
+ *   <Prompt name="test">
+ *     <Role>Assistant</Role>
+ *   </Prompt>
+ * `;
+ * const element = await createPromptFromSource(source, 'test.prompt');
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Using custom components in browser environments
+ * const source = `
+ *   <Prompt name="test">
+ *     <MyCustomHeader>Welcome</MyCustomHeader>
+ *   </Prompt>
+ * `;
+ * const element = await createPromptFromSource(source, 'test.prompt', {
+ *   components: {
+ *     MyCustomHeader: MyCustomHeaderComponent,
+ *   }
+ * });
+ * ```
+ */
+export declare function createPromptFromSource(source: string, filename: string, options?: CreatePromptOptions): Promise<PuptElement>;
+/**
+ * Create a PuptElement by loading and transforming a TSX file.
+ * Reads the file, transforms the JSX, and evaluates it.
+ *
+ * @param filePath - Path to the TSX file
+ * @param options - Optional configuration
+ * @returns The default export as a PuptElement
+ *
+ * @example
+ * ```typescript
+ * const element = await createPrompt('./prompts/greeting.tsx');
+ * const result = render(element, { inputs: { name: 'World' } });
+ * ```
+ */
+export declare function createPrompt(filePath: string, options?: CreatePromptOptions): Promise<PuptElement>;
+//# sourceMappingURL=create-prompt.d.ts.map

package/dist/src/create-prompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-prompt.d.ts","sourceRoot":"","sources":["../../src/create-prompt.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE1D;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;CAC5C;AAED;;;GAGG;AACH,eAAO,MAAM,wBAAwB,+BAA+B,CAAC;AAErE;;GAEG;AACH,OAAO,CAAC,MAAM,CAAC;IACb,IAAI,0BAA0B,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,GAAG,SAAS,CAAC;CAC3E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,mBAAwB,GAChC,OAAO,CAAC,WAAW,CAAC,CAiEtB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,YAAY,CAChC,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,mBAAwB,GAChC,OAAO,CAAC,WAAW,CAAC,CAKtB"}

package/dist/src/index.d.ts

@@ -0,0 +1,39 @@
+export declare const VERSION = "0.0.0-development";
+export { TYPE, PROPS, CHILDREN, DEFERRED_REF } from './types/symbols';
+export { isPuptElement, isDeferredRef } from './types/element';
+export type { PuptNode, PuptElement, ComponentType, DeferredRef, LlmConfig, LlmProvider, OutputConfig, CodeConfig, UserConfig, RuntimeConfig, PromptConfig, EnvironmentContext, RenderContext, RenderOptions, RenderResult, RenderSuccess, RenderFailure, RenderError, PostExecutionAction, ReviewFileAction, OpenUrlAction, RunCommandAction, InputRequirement, ValidationResult, ValidationError, SearchablePrompt, SearchOptions, SearchResult, SearchResultMatch, SearchEngineConfig, PuptConfig, PuptLibrary, DiscoveredPrompt, LibraryLoadResult, PuptInitConfig, } from './types';
+export { LLM_PROVIDERS, inferProviderFromModel, DEFAULT_ENVIRONMENT, createEnvironment, createRuntimeConfig, ensureRuntimeCacheReady, } from './types';
+export { Component, isComponentClass, COMPONENT_MARKER } from './component';
+export { render } from './render';
+export { wrapWithDelimiter } from './utils/delimiter';
+export { findChildrenOfType, partitionChildren, isElementOfType } from './utils/children';
+export { PROVIDER_ADAPTATIONS, LANGUAGE_CONVENTIONS, ROLE_PRESETS, TASK_PRESETS, CONSTRAINT_PRESETS, STEPS_PRESETS, DEFAULT_CONSTRAINTS, STANDARD_GUARDRAILS, EDGE_CASE_PRESETS, FALLBACK_PRESETS, } from '../components/presets';
+export type { ProviderAdaptations } from '../components/presets';
+export type { RolePresetConfig } from '../components/presets';
+export type { TaskPresetConfig } from '../components/presets';
+export type { ConstraintPresetConfig } from '../components/presets';
+export type { StepsPresetConfig } from '../components/presets';
+export { createInputIterator } from './services/input-iterator';
+export type { InputIterator, InputIteratorOptions, OnMissingDefaultStrategy } from './services/input-iterator';
+export { evaluateFormula } from './services/formula-parser';
+export { Transformer } from './services/transformer';
+export { evaluateModule } from './services/module-evaluator';
+export type { EvaluateOptions } from './services/module-evaluator';
+export { preprocessSource, isPromptFile, needsPreprocessing } from './services/preprocessor';
+export type { PreprocessOptions } from './services/preprocessor';
+export { getBuiltinComponents, getAskComponents, getAskShorthand, getStructuralComponents, } from './services/component-discovery';
+export { ModuleLoader } from './services/module-loader';
+export type { SourceType, LoadedLibrary, ParsedPackageSource } from './services/module-loader';
+export { resolveCdn, generateImportMap, serializeImportMap, generateImportMapScript, generatePuptLibImportMap, generatePuptLibImportMapScript, } from './services/browser-support';
+export type { CdnProvider, CdnOptions, Dependency, ImportMap, PuptLibImportMapOptions, } from './services/browser-support';
+export * from '../components';
+export { askBaseSchema, attachRequirement } from '../components/ask/utils';
+export { createPromptFromSource, createPrompt } from './create-prompt';
+export type { CreatePromptOptions } from './create-prompt';
+export { Pupt } from './api';
+export type { DiscoveredPromptWithMethods } from './api';
+export { createSearchEngine } from './services/search-engine';
+export type { SearchEngine } from './services/search-engine';
+export { FileSearchEngine, createFileSearchEngine } from './services/file-search-engine';
+export type { FileInfo, FileSearchResult, FileSearchEngineConfig, } from './services/file-search-engine';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"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"}

package/dist/src/jsx-runtime/index.d.ts

@@ -0,0 +1,29 @@
+import { PuptElement, PuptNode, ComponentType } from '../types';
+/**
+ * Fragment symbol for grouping elements without a wrapper
+ */
+export declare const Fragment: unique symbol;
+/**
+ * Create a JSX element with a single child.
+ * Called by the JSX transform for elements with one child.
+ *
+ * @param type - Element type (string tag, symbol like Fragment, or component)
+ * @param props - Properties including children
+ * @returns A PuptElement
+ */
+export declare function jsx<P extends Record<string, unknown>>(type: string | symbol | ComponentType<P>, props: P & {
+    children?: PuptNode;
+}): PuptElement<P>;
+/**
+ * Create a JSX element with multiple children.
+ * Called by the JSX transform for elements with multiple children.
+ * Implementation is the same as jsx since we normalize children either way.
+ *
+ * @param type - Element type (string tag, symbol like Fragment, or component)
+ * @param props - Properties including children array
+ * @returns A PuptElement
+ */
+export declare function jsxs<P extends Record<string, unknown>>(type: string | symbol | ComponentType<P>, props: P & {
+    children?: PuptNode;
+}): PuptElement<P>;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/jsx-runtime/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/jsx-runtime/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,aAAa,EAAe,MAAM,UAAU,CAAC;AAGlF;;GAEG;AACH,eAAO,MAAM,QAAQ,eAA8B,CAAC;AA6IpD;;;;;;;GAOG;AACH,wBAAgB,GAAG,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnD,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,aAAa,CAAC,CAAC,CAAC,EACxC,KAAK,EAAE,CAAC,GAAG;IAAE,QAAQ,CAAC,EAAE,QAAQ,CAAA;CAAE,GACjC,WAAW,CAAC,CAAC,CAAC,CAQhB;AAED;;;;;;;;GAQG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACpD,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,aAAa,CAAC,CAAC,CAAC,EACxC,KAAK,EAAE,CAAC,GAAG;IAAE,QAAQ,CAAC,EAAE,QAAQ,CAAA;CAAE,GACjC,WAAW,CAAC,CAAC,CAAC,CAEhB"}

package/dist/src/jsx-runtime/jsx-dev-runtime.d.ts

@@ -0,0 +1,26 @@
+import { PuptElement, PuptNode, ComponentType } from '../types';
+export { Fragment, jsx, jsxs } from './index';
+/**
+ * Source location information for development debugging
+ */
+export interface JSXSource {
+    fileName: string;
+    lineNumber: number;
+    columnNumber: number;
+}
+/**
+ * Development version of jsx that includes source location tracking.
+ * Used by React/JSX transforms in development mode.
+ *
+ * @param type - Element type
+ * @param props - Properties including children
+ * @param _key - Element key (unused in pupt-lib)
+ * @param _isStaticChildren - Whether children are static (unused)
+ * @param _source - Source location for debugging
+ * @param _self - Self reference (unused)
+ * @returns A PuptElement
+ */
+export declare function jsxDEV<P extends Record<string, unknown>>(type: string | symbol | ComponentType<P>, props: P & {
+    children?: PuptNode;
+}, _key: string | undefined, _isStaticChildren: boolean, _source: JSXSource, _self: unknown): PuptElement<P>;
+//# sourceMappingURL=jsx-dev-runtime.d.ts.map

package/dist/src/jsx-runtime/jsx-dev-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsx-dev-runtime.d.ts","sourceRoot":"","sources":["../../../src/jsx-runtime/jsx-dev-runtime.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAGrE,OAAO,EAAE,QAAQ,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAE9C;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACtD,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,aAAa,CAAC,CAAC,CAAC,EACxC,KAAK,EAAE,CAAC,GAAG;IAAE,QAAQ,CAAC,EAAE,QAAQ,CAAA;CAAE,EAClC,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,iBAAiB,EAAE,OAAO,EAC1B,OAAO,EAAE,SAAS,EAClB,KAAK,EAAE,OAAO,GACb,WAAW,CAAC,CAAC,CAAC,CAIhB"}

package/dist/src/render.d.ts

@@ -0,0 +1,19 @@
+import { PuptElement, RenderResult, RenderOptions } from './types';
+/**
+ * Render a PuptElement tree to a string.
+ *
+ * This function is async to support components with async render methods.
+ * Components can perform async operations like API calls in their render methods.
+ *
+ * @param element - The root PuptElement to render
+ * @param options - Render options including inputs and environment
+ * @returns A Promise resolving to the RenderResult
+ *
+ * @example
+ * ```typescript
+ * const result = await render(<MyPrompt />);
+ * console.log(result.text);
+ * ```
+ */
+export declare function render(element: PuptElement, options?: RenderOptions): Promise<RenderResult>;
+//# sourceMappingURL=render.d.ts.map

package/dist/src/render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../../src/render.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAY,YAAY,EAAE,aAAa,EAAmD,MAAM,SAAS,CAAC;AAuInI;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,MAAM,CAC1B,OAAO,EAAE,WAAW,EACpB,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC,YAAY,CAAC,CA2DvB"}

package/dist/src/services/babel-plugins/index.d.ts

@@ -0,0 +1,3 @@
+export { usesToImportPlugin } from './uses-to-import';
+export { nameHoistingPlugin } from './name-hoisting';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/services/babel-plugins/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/services/babel-plugins/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/src/services/babel-plugins/name-hoisting.d.ts

@@ -0,0 +1,8 @@
+import { PluginObj, types as BabelTypes } from '@babel/core';
+/**
+ * Babel plugin that hoists named JSX elements to variable declarations.
+ */
+export declare function nameHoistingPlugin({ types: t }: {
+    types: typeof BabelTypes;
+}): PluginObj;
+//# sourceMappingURL=name-hoisting.d.ts.map

package/dist/src/services/babel-plugins/name-hoisting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"name-hoisting.d.ts","sourceRoot":"","sources":["../../../../src/services/babel-plugins/name-hoisting.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,KAAK,IAAI,UAAU,EAAY,MAAM,aAAa,CAAC;AAuJ5E;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE;IAAE,KAAK,EAAE,OAAO,UAAU,CAAA;CAAE,GAAG,SAAS,CA0GxF"}

package/dist/src/services/babel-plugins/uses-to-import.d.ts

@@ -0,0 +1,16 @@
+import { PluginObj, types as BabelTypes } from '@babel/core';
+interface PluginState {
+    file: {
+        path: {
+            unshiftContainer: (key: string, node: BabelTypes.Statement | BabelTypes.Statement[]) => void;
+        };
+    };
+}
+/**
+ * Babel plugin that transforms <Uses> elements to import declarations.
+ */
+export declare function usesToImportPlugin({ types: t }: {
+    types: typeof BabelTypes;
+}): PluginObj<PluginState>;
+export {};
+//# sourceMappingURL=uses-to-import.d.ts.map

package/dist/src/services/babel-plugins/uses-to-import.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uses-to-import.d.ts","sourceRoot":"","sources":["../../../../src/services/babel-plugins/uses-to-import.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,KAAK,IAAI,UAAU,EAAE,MAAM,aAAa,CAAC;AAElE,UAAU,WAAW;IACnB,IAAI,EAAE;QACJ,IAAI,EAAE;YACJ,gBAAgB,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,CAAC,SAAS,GAAG,UAAU,CAAC,SAAS,EAAE,KAAK,IAAI,CAAC;SAC9F,CAAC;KACH,CAAC;CACH;AA0GD;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE;IAAE,KAAK,EAAE,OAAO,UAAU,CAAA;CAAE,GAAG,SAAS,CAAC,WAAW,CAAC,CA6CrG"}

package/dist/src/services/browser-support.d.ts

@@ -0,0 +1,185 @@
+/**
+ * Browser support utilities for pupt-lib.
+ * Provides import map generation and CDN URL resolution for browser environments.
+ */
+/**
+ * Supported CDN providers
+ */
+export type CdnProvider = 'esm.sh' | 'unpkg' | 'jsdelivr' | 'skypack';
+/**
+ * Options for CDN resolution
+ */
+export interface CdnOptions {
+    /** CDN provider to use */
+    cdn?: CdnProvider;
+    /** Custom template URL with {name}, {version}, and optionally {path} placeholders */
+    cdnTemplate?: string;
+    /** Optional path within the package (e.g., 'dist/index.js') */
+    path?: string;
+    /** Optional scopes for import map */
+    scopes?: Record<string, Record<string, string>>;
+}
+/**
+ * Represents a dependency for import map generation
+ */
+export interface Dependency {
+    name: string;
+    version: string;
+}
+/**
+ * Standard import map structure
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script/type/importmap
+ */
+export interface ImportMap {
+    imports: Record<string, string>;
+    scopes?: Record<string, Record<string, string>>;
+}
+/**
+ * Resolve a CDN URL for a package.
+ *
+ * @param name - Package name (e.g., '@acme/pkg' or 'lodash')
+ * @param version - Package version (e.g., '1.0.0')
+ * @param options - CDN options
+ * @returns The resolved CDN URL
+ *
+ * @example
+ * ```typescript
+ * resolveCdn('@acme/pkg', '1.0.0', { cdn: 'esm.sh' });
+ * // => 'https://esm.sh/@acme/pkg@1.0.0'
+ *
+ * resolveCdn('@acme/pkg', '1.0.0', { cdn: 'unpkg' });
+ * // => 'https://unpkg.com/@acme/pkg@1.0.0'
+ *
+ * resolveCdn('@acme/pkg', '1.0.0', {
+ *   cdnTemplate: 'https://cdn.example.com/{name}@{version}'
+ * });
+ * // => 'https://cdn.example.com/@acme/pkg@1.0.0'
+ * ```
+ */
+export declare function resolveCdn(name: string, version: string, options: CdnOptions): string;
+/**
+ * Generate an import map for a list of dependencies.
+ *
+ * @param dependencies - Array of dependencies with name and version
+ * @param options - CDN options
+ * @returns An ImportMap object ready to be serialized
+ *
+ * @example
+ * ```typescript
+ * const deps = [
+ *   { name: 'pupt-lib', version: '1.0.0' },
+ *   { name: '@acme/prompts', version: '2.0.0' },
+ * ];
+ *
+ * const importMap = generateImportMap(deps, { cdn: 'esm.sh' });
+ * // => {
+ * //      imports: {
+ * //        'pupt-lib': 'https://esm.sh/pupt-lib@1.0.0',
+ * //        '@acme/prompts': 'https://esm.sh/@acme/prompts@2.0.0'
+ * //      }
+ * //    }
+ * ```
+ */
+export declare function generateImportMap(dependencies: Dependency[], options: CdnOptions): ImportMap;
+/**
+ * Serialize an import map to a JSON string for embedding in HTML.
+ *
+ * @param importMap - The import map to serialize
+ * @returns JSON string
+ *
+ * @example
+ * ```typescript
+ * const json = serializeImportMap(importMap);
+ * // Use in HTML: <script type="importmap">${json}</script>
+ * ```
+ */
+export declare function serializeImportMap(importMap: ImportMap): string;
+/**
+ * Generate an HTML script tag with an import map.
+ *
+ * @param dependencies - Array of dependencies with name and version
+ * @param options - CDN options
+ * @returns HTML string for the import map script tag
+ *
+ * @example
+ * ```typescript
+ * const html = generateImportMapScript(deps, { cdn: 'esm.sh' });
+ * // => <script type="importmap">{"imports": {...}}</script>
+ * ```
+ */
+export declare function generateImportMapScript(dependencies: Dependency[], options: CdnOptions): string;
+/**
+ * Options for generating pupt-lib import map
+ */
+export interface PuptLibImportMapOptions {
+    /** CDN provider to use (default: 'esm.sh') */
+    cdn?: CdnProvider;
+    /** Custom CDN template URL */
+    cdnTemplate?: string;
+    /** pupt-lib version (default: current installed version) */
+    puptLibVersion?: string;
+    /** Additional dependencies to include */
+    additionalDependencies?: Dependency[];
+}
+/**
+ * Generate an import map for browser usage of pupt-lib.
+ *
+ * This creates the minimal import map required to use `createPromptFromSource`
+ * in browser environments. It includes:
+ * - pupt-lib main entry
+ * - pupt-lib/jsx-runtime subpath
+ *
+ * Note: zod, minisearch, and @babel/standalone are bundled into pupt-lib's dist
+ * and do not need separate import map entries.
+ *
+ * @param options - Configuration options
+ * @returns An ImportMap object ready to be serialized
+ *
+ * @example
+ * ```typescript
+ * // Using esm.sh (default)
+ * const importMap = generatePuptLibImportMap({ puptLibVersion: '1.1.0' });
+ *
+ * // Using unpkg
+ * const importMap = generatePuptLibImportMap({
+ *   puptLibVersion: '1.1.0',
+ *   cdn: 'unpkg'
+ * });
+ *
+ * // With additional dependencies
+ * const importMap = generatePuptLibImportMap({
+ *   puptLibVersion: '1.1.0',
+ *   additionalDependencies: [
+ *     { name: 'my-component-lib', version: '2.0.0' }
+ *   ]
+ * });
+ * ```
+ *
+ * @example
+ * ```html
+ * <!-- Usage in HTML -->
+ * <script type="importmap">
+ *   {
+ *     "imports": {
+ *       "pupt-lib": "https://esm.sh/pupt-lib@1.1.0",
+ *       "pupt-lib/jsx-runtime": "https://esm.sh/pupt-lib@1.1.0/jsx-runtime"
+ *     }
+ *   }
+ * </script>
+ * ```
+ */
+export declare function generatePuptLibImportMap(options?: PuptLibImportMapOptions): ImportMap;
+/**
+ * Generate an HTML script tag with the pupt-lib import map.
+ *
+ * @param options - Configuration options
+ * @returns HTML string for the import map script tag
+ *
+ * @example
+ * ```typescript
+ * const html = generatePuptLibImportMapScript({ puptLibVersion: '1.1.0' });
+ * // Use in HTML head: document.head.insertAdjacentHTML('afterbegin', html);
+ * ```
+ */
+export declare function generatePuptLibImportMapScript(options?: PuptLibImportMapOptions): string;
+//# sourceMappingURL=browser-support.d.ts.map

package/dist/src/services/browser-support.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-support.d.ts","sourceRoot":"","sources":["../../../src/services/browser-support.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG,OAAO,GAAG,UAAU,GAAG,SAAS,CAAC;AAYtE;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,0BAA0B;IAC1B,GAAG,CAAC,EAAE,WAAW,CAAC;IAClB,qFAAqF;IACrF,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,+DAA+D;IAC/D,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,qCAAqC;IACrC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CACjD;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;GAGG;AACH,MAAM,WAAW,SAAS;IACxB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CACjD;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,UAAU,GAClB,MAAM,CAsBR;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,iBAAiB,CAC/B,YAAY,EAAE,UAAU,EAAE,EAC1B,OAAO,EAAE,UAAU,GAClB,SAAS,CAeX;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,SAAS,GAAG,MAAM,CAE/D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,uBAAuB,CACrC,YAAY,EAAE,UAAU,EAAE,EAC1B,OAAO,EAAE,UAAU,GAClB,MAAM,CAIR;AAED;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,8CAA8C;IAC9C,GAAG,CAAC,EAAE,WAAW,CAAC;IAClB,8BAA8B;IAC9B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,4DAA4D;IAC5D,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,yCAAyC;IACzC,sBAAsB,CAAC,EAAE,UAAU,EAAE,CAAC;CACvC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,GAAE,uBAA4B,GACpC,SAAS,CA2BX;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,8BAA8B,CAC5C,OAAO,GAAE,uBAA4B,GACpC,MAAM,CAIR"}

package/dist/src/services/component-discovery.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Dynamic component discovery for the preprocessor and babel plugins.
+ *
+ * Instead of importing a static manifest from components/, this module
+ * builds component lists lazily from the actual component exports.
+ * src/index.ts registers a thunk that provides the exports; the lists
+ * are computed on first access (at runtime, when all modules are loaded).
+ */
+type ExportMap = Record<string, unknown>;
+type ExportThunk = () => ExportMap;
+/**
+ * Register a thunk that returns the component exports.
+ * Called by src/index.ts during module initialization.
+ * The thunk is evaluated lazily to avoid circular dependency issues.
+ */
+export declare function setComponentExportsThunk(thunk: ExportThunk): void;
+/**
+ * All built-in non-Ask component names, derived from actual exports.
+ * Includes 'Component' (the base class).
+ */
+export declare function getBuiltinComponents(): readonly string[];
+/**
+ * All Ask component names (Ask namespace + individual AskX exports).
+ */
+export declare function getAskComponents(): readonly string[];
+/**
+ * Shorthand aliases: short name → AskX full name.
+ * e.g., { Text: 'AskText', Number: 'AskNumber', ... }
+ *
+ * Skips shorthands that would conflict with builtin component names.
+ */
+export declare function getAskShorthand(): Record<string, string>;
+/**
+ * Structural component names whose `name` prop is for identification,
+ * not variable creation. The name-hoisting Babel plugin skips these.
+ *
+ * Computed as: all builtins minus Component (base class), minus components
+ * with `static hoistName = true`, plus Fragment.
+ */
+export declare function getStructuralComponents(): readonly string[];
+export {};
+//# sourceMappingURL=component-discovery.d.ts.map

package/dist/src/services/component-discovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-discovery.d.ts","sourceRoot":"","sources":["../../../src/services/component-discovery.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,KAAK,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AACzC,KAAK,WAAW,GAAG,MAAM,SAAS,CAAC;AAUnC;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI,CAOjE;AAWD;;;GAGG;AACH,wBAAgB,oBAAoB,IAAI,SAAS,MAAM,EAAE,CAcxD;AAED;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,SAAS,MAAM,EAAE,CAapD;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAgBxD;AAUD;;;;;;GAMG;AACH,wBAAgB,uBAAuB,IAAI,SAAS,MAAM,EAAE,CAa3D"}