import { Layer, ServiceMap, Effect, Stream } from 'effect';

/**
 * Sandbox public type definitions.
 */
interface TraceSpan {
    readonly spanId: string;
    readonly parentSpanId?: string;
    readonly name: string;
    readonly startTime: number;
    readonly endTime?: number;
    readonly status: 'running' | 'success' | 'error' | 'cancelled';
    readonly attributes?: Record<string, unknown>;
    readonly intentId?: string;
    readonly stepId?: string;
}
type LogLevel = 'debug' | 'info' | 'warn' | 'error';
interface LogEntry {
    readonly level: LogLevel;
    readonly args: ReadonlyArray<unknown>;
    readonly timestamp: number;
    readonly source?: 'console' | 'effect' | 'logix';
}
type SandboxStatus = 'idle' | 'initializing' | 'ready' | 'running' | 'completed' | 'error';
type DiagnosticsLevel = 'off' | 'light' | 'sampled' | 'full';
/**
 * Stable identifier for a kernel variant.
 *
 * - Recommended: `[a-z0-9-]+` (lower-kebab)
 * - Recommended reserved name: `core`
 */
type KernelId = string;
interface KernelVariant {
    readonly kernelId: KernelId;
    /** Optional label for UI display. */
    readonly label?: string;
    /**
     * URL of the kernel entry (logix-core.js).
     * Sibling `effect.js` and `logix-core.manifest.json` are derived by convention.
     */
    readonly kernelUrl: string;
}
interface KernelRegistry {
    /** Available kernel variants. Order should be stable (recommend: registration order). */
    readonly kernels: ReadonlyArray<KernelVariant>;
    /**
     * Default kernelId when no kernelId is requested and the fallback target when allowed.
     * Required when multiple kernels exist.
     */
    readonly defaultKernelId?: KernelId;
    /** Whether cross-origin kernel resources are allowed (default should be false). */
    readonly allowCrossOrigin?: boolean;
}
interface HttpMockRule {
    readonly url: string;
    readonly method?: string;
    readonly status?: number;
    readonly delayMs?: number;
    readonly json?: unknown;
}
interface MockManifest {
    readonly http?: ReadonlyArray<HttpMockRule>;
}
interface UiIntentPacket {
    readonly id: string;
    readonly component: string;
    readonly intent: 'mount' | 'update' | 'unmount' | 'action';
    readonly props: Record<string, unknown>;
    readonly callbacks: ReadonlyArray<string>;
    readonly children?: ReadonlyArray<UiIntentPacket>;
    readonly meta?: {
        readonly storyId?: string;
        readonly stepId?: string;
        readonly label?: string;
        readonly severity?: 'info' | 'warn' | 'error';
        readonly tags?: ReadonlyArray<string>;
    };
}
interface RunResult {
    readonly runId: string;
    readonly duration: number;
    /**
     * 058 multi-kernel summary fields.
     * These fields are optional for single-kernel usage.
     */
    readonly requestedKernelId?: KernelId;
    readonly effectiveKernelId?: KernelId;
    readonly fallbackReason?: string;
    /** Extracted from TrialRunReport.environment.kernelImplementationRef (045). */
    readonly kernelImplementationRef?: unknown;
    readonly stateSnapshot?: unknown;
    readonly traces: ReadonlyArray<TraceSpan>;
    readonly logs: ReadonlyArray<LogEntry>;
    readonly uiIntents?: ReadonlyArray<UiIntentPacket>;
}
type SandboxErrorCode = 'INIT_FAILED' | 'RUNTIME_ERROR' | 'TIMEOUT' | 'WORKER_TERMINATED';
interface SandboxErrorInfo {
    readonly code: SandboxErrorCode;
    readonly message: string;
    readonly stack?: string;
    readonly requestedKernelId?: KernelId;
    readonly availableKernelIds?: ReadonlyArray<KernelId>;
    readonly effectiveKernelId?: KernelId;
    readonly fallbackReason?: string;
}

interface SandboxClientConfig {
    readonly workerUrl?: string;
    readonly timeout?: number;
    readonly wasmUrl?: string;
    readonly kernelUrl?: string;
    readonly kernelRegistry?: KernelRegistry;
}

interface SandboxClientService {
    readonly init: () => Effect.Effect<void, unknown>;
    readonly listKernels: () => Effect.Effect<{
        readonly kernels: ReadonlyArray<KernelVariant>;
        readonly defaultKernelId?: KernelId;
    }, never>;
    readonly compile: (code: string, filename?: string, mockManifest?: MockManifest, options?: {
        readonly kernelId?: KernelId;
        readonly strict?: boolean;
        readonly allowFallback?: boolean;
    }) => Effect.Effect<{
        success: boolean;
        bundle?: string;
        errors?: string[];
    }, unknown>;
    readonly run: (options?: {
        readonly runId?: string;
        readonly actions?: ReadonlyArray<{
            _tag: string;
            payload?: unknown;
        }>;
        readonly useCompiledCode?: boolean;
        readonly kernelId?: KernelId;
        readonly strict?: boolean;
        readonly allowFallback?: boolean;
    }) => Effect.Effect<RunResult, unknown>;
    readonly trial: (options: {
        readonly moduleCode: string;
        readonly moduleExport?: string;
        readonly runId?: string;
        readonly buildEnvConfig?: Record<string, string | number | boolean>;
        readonly diagnosticsLevel?: DiagnosticsLevel;
        readonly maxEvents?: number;
        readonly trialRunTimeoutMs?: number;
        readonly closeScopeTimeout?: number;
        readonly reportMaxBytes?: number;
        readonly filename?: string;
        readonly mockManifest?: MockManifest;
        readonly kernelId?: KernelId;
        readonly strict?: boolean;
        readonly allowFallback?: boolean;
    }) => Effect.Effect<RunResult, unknown>;
    readonly uiCallback: (payload: {
        runId: string;
        intentId: string;
        callback: string;
        data?: unknown;
    }) => Effect.Effect<void, unknown>;
    readonly terminate: () => Effect.Effect<void, unknown>;
    readonly events: Stream.Stream<{
        status: SandboxStatus;
        logs: ReadonlyArray<LogEntry>;
        traces: ReadonlyArray<TraceSpan>;
        error: SandboxErrorInfo | null;
        uiIntents: ReadonlyArray<UiIntentPacket>;
    }>;
}
declare const SandboxClientTag_base: ServiceMap.ServiceClass<SandboxClientTag, "SandboxClientTag", SandboxClientService>;
declare class SandboxClientTag extends SandboxClientTag_base {
}
declare const SandboxClientLayer: (config?: SandboxClientConfig) => Layer.Layer<SandboxClientTag, never, never>;

export { SandboxClientLayer, SandboxClientTag };