@renderify/core 0.1.0

package/dist/core.d.ts

@@ -0,0 +1,335 @@
+import { RuntimePlan, RuntimeExecutionResult } from '@renderify/ir';
+import { RenderTarget, RuntimeManager, UIRenderer } from '@renderify/runtime';
+export { DefaultUIRenderer, InteractiveRenderTarget, RenderTarget, RuntimeEventDispatchRequest, UIRenderer } from '@renderify/runtime';
+import { RuntimeSecurityPolicy, SecurityCheckResult, SecurityChecker } from '@renderify/security';
+export * from '@renderify/security';
+
+interface ApiDefinition {
+    name: string;
+    endpoint: string;
+    method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+    headers?: Record<string, string>;
+    timeoutMs?: number;
+}
+interface ApiIntegration {
+    registerApi(api: ApiDefinition): void;
+    listApis(): ApiDefinition[];
+    callApi<TResponse = unknown>(name: string, params?: Record<string, unknown>): Promise<TResponse>;
+}
+declare class DefaultApiIntegration implements ApiIntegration {
+    private readonly apis;
+    registerApi(api: ApiDefinition): void;
+    listApis(): ApiDefinition[];
+    callApi<TResponse = unknown>(name: string, params?: Record<string, unknown>): Promise<TResponse>;
+    private buildUrl;
+    private createTimeout;
+}
+
+interface CodeGenerationInput {
+    prompt: string;
+    llmText: string;
+    context?: Record<string, unknown>;
+}
+interface IncrementalCodeGenerationInput {
+    prompt: string;
+    context?: Record<string, unknown>;
+}
+interface IncrementalCodeGenerationUpdate {
+    plan: RuntimePlan;
+    complete: boolean;
+    mode: "runtime-plan-json" | "runtime-node-json" | "runtime-source" | "runtime-text-fallback";
+}
+interface IncrementalCodeGenerationSession {
+    pushDelta(delta: string): Promise<IncrementalCodeGenerationUpdate | undefined>;
+    finalize(finalText?: string): Promise<RuntimePlan | undefined>;
+}
+interface CodeGenerator {
+    generatePlan(input: CodeGenerationInput): Promise<RuntimePlan>;
+    createIncrementalSession?(input: IncrementalCodeGenerationInput): IncrementalCodeGenerationSession;
+    validatePlan(plan: RuntimePlan): Promise<boolean>;
+    transformPlan(plan: RuntimePlan, transforms: Array<(plan: RuntimePlan) => RuntimePlan>): Promise<RuntimePlan>;
+}
+declare class DefaultCodeGenerator implements CodeGenerator {
+    createIncrementalSession(input: IncrementalCodeGenerationInput): IncrementalCodeGenerationSession;
+    generatePlan(input: CodeGenerationInput): Promise<RuntimePlan>;
+    validatePlan(plan: RuntimePlan): Promise<boolean>;
+    transformPlan(plan: RuntimePlan, transforms: Array<(plan: RuntimePlan) => RuntimePlan>): Promise<RuntimePlan>;
+    private createFallbackRoot;
+    private tryBuildIncrementalCandidate;
+    private createIncrementalPlanSignature;
+    private hashIncrementalSignatureValue;
+    private createPlanFromRoot;
+    private tryParseRuntimePlan;
+    private tryParseRuntimeNode;
+    private tryParseJsonPayload;
+    private isLikelyCompleteJsonPayload;
+    private hasClosedCodeFence;
+    private normalizePlanId;
+    private normalizePlanVersion;
+    private normalizeImports;
+    private normalizeModuleManifest;
+    private normalizeCapabilities;
+    private createModuleManifestFromImports;
+    private resolveImportToUrl;
+    private extractVersionFromSpecifier;
+    private normalizeMetadata;
+    private tryExtractRuntimeSource;
+    private createSourcePlan;
+    private parseImportsFromSource;
+    private isHttpUrl;
+    private isRecord;
+    private normalizeSourceModule;
+    private inferSourceRuntimeFromLanguage;
+    private resolveJspmSpecifier;
+}
+
+type SecurityProfileConfig = "strict" | "balanced" | "relaxed";
+type LLMProviderConfig = string;
+interface RenderifyConfigValues {
+    llmApiKey?: string;
+    llmProvider: LLMProviderConfig;
+    llmModel: string;
+    llmBaseUrl: string;
+    llmRequestTimeoutMs: number;
+    llmUseStructuredOutput: boolean;
+    jspmCdnUrl: string;
+    strictSecurity: boolean;
+    securityProfile: SecurityProfileConfig;
+    securityPolicy?: Partial<RuntimeSecurityPolicy>;
+    runtimeJspmOnlyStrictMode: boolean;
+    runtimeEnforceModuleManifest: boolean;
+    runtimeAllowIsolationFallback: boolean;
+    runtimeSupportedSpecVersions: string[];
+    runtimeEnableDependencyPreflight: boolean;
+    runtimeFailOnDependencyPreflightError: boolean;
+    runtimeRemoteFetchTimeoutMs: number;
+    runtimeRemoteFetchRetries: number;
+    runtimeRemoteFetchBackoffMs: number;
+    runtimeRemoteFallbackCdnBases: string[];
+    runtimeBrowserSourceSandboxMode: "none" | "worker" | "iframe";
+    runtimeBrowserSourceSandboxTimeoutMs: number;
+    runtimeBrowserSourceSandboxFailClosed: boolean;
+    [key: string]: unknown;
+}
+interface JspmOnlyStrictModeOptions {
+    allowedNetworkHosts?: string[];
+}
+declare function createJspmOnlyStrictModeConfig(options?: JspmOnlyStrictModeOptions): Partial<RenderifyConfigValues>;
+interface RenderifyConfig {
+    load(overrides?: Partial<RenderifyConfigValues>): Promise<void>;
+    get<T = unknown>(key: string): T | undefined;
+    set(key: string, value: unknown): void;
+    snapshot(): Readonly<Record<string, unknown>>;
+    save(): Promise<void>;
+}
+declare class DefaultRenderifyConfig implements RenderifyConfig {
+    private config;
+    load(overrides?: Partial<RenderifyConfigValues>): Promise<void>;
+    get<T = unknown>(key: string): T | undefined;
+    set(key: string, value: unknown): void;
+    snapshot(): Readonly<Record<string, unknown>>;
+    save(): Promise<void>;
+}
+
+interface RenderifyContext {
+    user?: {
+        id: string;
+        name?: string;
+        role?: string;
+    };
+    app?: {
+        version: string;
+        environment?: "development" | "staging" | "production";
+    };
+    [key: string]: unknown;
+}
+interface ContextManager {
+    initialize(): Promise<void>;
+    getContext(): RenderifyContext;
+    updateContext(partialCtx: Partial<RenderifyContext>): void;
+    subscribe(listener: (ctx: RenderifyContext) => void): () => void;
+}
+declare class DefaultContextManager implements ContextManager {
+    private ctx;
+    private listeners;
+    initialize(): Promise<void>;
+    getContext(): RenderifyContext;
+    updateContext(partialCtx: Partial<RenderifyContext>): void;
+    subscribe(listener: (ctx: RenderifyContext) => void): () => void;
+    private notify;
+}
+
+type PluginHook = "beforeLLM" | "afterLLM" | "beforeCodeGen" | "afterCodeGen" | "beforePolicyCheck" | "afterPolicyCheck" | "beforeRuntime" | "afterRuntime" | "beforeRender" | "afterRender";
+interface PluginContext {
+    traceId: string;
+    hookName: PluginHook;
+}
+type PluginHandler<Payload = unknown> = (payload: Payload, context: PluginContext) => Payload | Promise<Payload>;
+interface RenderifyPlugin {
+    name: string;
+    hooks: Partial<Record<PluginHook, PluginHandler>>;
+}
+interface CustomizationEngine {
+    registerPlugin(plugin: RenderifyPlugin): void;
+    getPlugins(): RenderifyPlugin[];
+    runHook<Payload>(hookName: PluginHook, payload: Payload, context: PluginContext): Promise<Payload>;
+}
+declare class DefaultCustomizationEngine implements CustomizationEngine {
+    private plugins;
+    registerPlugin(plugin: RenderifyPlugin): void;
+    getPlugins(): RenderifyPlugin[];
+    runHook<Payload>(hookName: PluginHook, payload: Payload, context: PluginContext): Promise<Payload>;
+}
+
+interface LLMRequest {
+    prompt: string;
+    context?: Record<string, unknown>;
+    systemPrompt?: string;
+    signal?: AbortSignal;
+}
+interface LLMResponse {
+    text: string;
+    tokensUsed?: number;
+    model?: string;
+    raw?: unknown;
+}
+interface LLMResponseStreamChunk {
+    delta: string;
+    text: string;
+    done: boolean;
+    index: number;
+    tokensUsed?: number;
+    model?: string;
+    raw?: unknown;
+}
+interface LLMStructuredRequest extends LLMRequest {
+    format: "runtime-plan";
+    strict?: boolean;
+}
+interface LLMStructuredResponse<T = unknown> {
+    text: string;
+    value?: T;
+    valid: boolean;
+    errors?: string[];
+    tokensUsed?: number;
+    model?: string;
+    raw?: unknown;
+}
+interface LLMInterpreter {
+    configure(options: Record<string, unknown>): void;
+    generateResponse(req: LLMRequest): Promise<LLMResponse>;
+    generateResponseStream?(req: LLMRequest): AsyncIterable<LLMResponseStreamChunk>;
+    generateStructuredResponse?<T = unknown>(req: LLMStructuredRequest): Promise<LLMStructuredResponse<T>>;
+    setPromptTemplate(templateName: string, templateContent: string): void;
+    getPromptTemplate(templateName: string): string | undefined;
+}
+
+interface PerformanceMetric {
+    label: string;
+    startedAt: number;
+    endedAt: number;
+    durationMs: number;
+}
+interface PerformanceOptimizer {
+    startMeasurement(label: string): void;
+    endMeasurement(label: string): PerformanceMetric | undefined;
+    getMetrics(): PerformanceMetric[];
+    reset(): void;
+}
+declare class DefaultPerformanceOptimizer implements PerformanceOptimizer {
+    private readonly timers;
+    private readonly metrics;
+    startMeasurement(label: string): void;
+    endMeasurement(label: string): PerformanceMetric | undefined;
+    getMetrics(): PerformanceMetric[];
+    reset(): void;
+}
+
+interface RenderifyCoreDependencies {
+    config: RenderifyConfig;
+    context: ContextManager;
+    llm: LLMInterpreter;
+    codegen: CodeGenerator;
+    runtime: RuntimeManager;
+    security: SecurityChecker;
+    performance: PerformanceOptimizer;
+    ui: UIRenderer;
+    apiIntegration?: ApiIntegration;
+    customization?: CustomizationEngine;
+}
+interface RenderPromptOptions {
+    target?: RenderTarget;
+    traceId?: string;
+    signal?: AbortSignal;
+}
+interface RenderPlanOptions {
+    target?: RenderTarget;
+    traceId?: string;
+    prompt?: string;
+    signal?: AbortSignal;
+}
+interface RenderPlanResult {
+    traceId: string;
+    plan: RuntimePlan;
+    security: SecurityCheckResult;
+    execution: RuntimeExecutionResult;
+    html: string;
+}
+interface RenderPromptResult extends RenderPlanResult {
+    prompt: string;
+    llm: LLMResponse;
+}
+interface RenderPromptStreamOptions extends RenderPromptOptions {
+    previewEveryChunks?: number;
+}
+interface RenderPromptStreamChunk {
+    type: "llm-delta" | "preview" | "final" | "error";
+    traceId: string;
+    prompt: string;
+    llmText: string;
+    delta?: string;
+    html?: string;
+    diagnostics?: RuntimeExecutionResult["diagnostics"];
+    planId?: string;
+    final?: RenderPromptResult;
+    error?: {
+        message: string;
+        name?: string;
+    };
+}
+type EventCallback = (...args: unknown[]) => void;
+declare class PolicyRejectionError extends Error {
+    readonly result: SecurityCheckResult;
+    constructor(result: SecurityCheckResult);
+}
+declare class RenderifyApp {
+    private readonly deps;
+    private readonly listeners;
+    private running;
+    constructor(deps: RenderifyCoreDependencies);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    renderPrompt(prompt: string, options?: RenderPromptOptions): Promise<RenderPromptResult>;
+    renderPromptStream(prompt: string, options?: RenderPromptStreamOptions): AsyncGenerator<RenderPromptStreamChunk, RenderPromptResult>;
+    renderPlan(plan: RuntimePlan, options?: RenderPlanOptions): Promise<RenderPlanResult>;
+    getConfig(): RenderifyConfig;
+    getContext(): ContextManager;
+    getLLM(): LLMInterpreter;
+    getCodeGenerator(): CodeGenerator;
+    getRuntimeManager(): RuntimeManager;
+    getSecurityChecker(): SecurityChecker;
+    on(eventName: string, callback: EventCallback): () => void;
+    emit(eventName: string, payload?: unknown): void;
+    private executePlanFlow;
+    private ensureRunning;
+    private runHook;
+    private toRecord;
+    private createTraceId;
+    private createMetricLabel;
+    private resolveUserId;
+    private buildStreamingPreview;
+    private throwIfAborted;
+}
+declare function createRenderifyApp(deps: RenderifyCoreDependencies): RenderifyApp;
+
+export { type ApiDefinition, type ApiIntegration, type CodeGenerationInput, type CodeGenerator, type ContextManager, type CustomizationEngine, DefaultApiIntegration, DefaultCodeGenerator, DefaultContextManager, DefaultCustomizationEngine, DefaultPerformanceOptimizer, DefaultRenderifyConfig, type IncrementalCodeGenerationInput, type IncrementalCodeGenerationSession, type IncrementalCodeGenerationUpdate, type JspmOnlyStrictModeOptions, type LLMInterpreter, type LLMProviderConfig, type LLMRequest, type LLMResponse, type LLMResponseStreamChunk, type LLMStructuredRequest, type LLMStructuredResponse, type PerformanceMetric, type PerformanceOptimizer, type PluginContext, type PluginHandler, type PluginHook, PolicyRejectionError, type RenderPlanOptions, type RenderPlanResult, type RenderPromptOptions, type RenderPromptResult, type RenderPromptStreamChunk, type RenderPromptStreamOptions, RenderifyApp, type RenderifyConfig, type RenderifyConfigValues, type RenderifyContext, type RenderifyCoreDependencies, type RenderifyPlugin, type SecurityProfileConfig, createJspmOnlyStrictModeConfig, createRenderifyApp };