import * as Data from "effect/Data"; export class KernelCoreEffectError extends Data.TaggedError("KernelCoreEffectError")<{  readonly module: string;  readonly message: string;  readonly cause?: unknown;}> {} /** * Default failure type for any `CodeExecutor.execute` implementation — * surfaces sandbox-level defects (isolate crash, module load failure, * worker loader error) as a typed error so callers can handle them * structurally instead of untyped `unknown`. Runtimes that want a * narrower error shape can define their own `Data.TaggedError` subclass * and parameterize `CodeExecutor<MyError>`. */export class CodeExecutionError extends Data.TaggedError("CodeExecutionError")<{  readonly runtime: string;  readonly message: string;  readonly cause?: unknown;}> {} /** * Raised when user code fails to compile before it ever runs: a genuine * syntax/parse error (smart quotes from a copy-paste, an unbalanced * brace, `const = 5`) caught while stripping TypeScript ahead of the * JS-only sandbox. Unlike `CodeExecutionError` this is the user's * mistake, not a sandbox defect, so runtimes surface its `message` * through the descriptive `ExecuteResult.error` channel instead of * collapsing it to an opaque internal-error string. The original parser * message (e.g. "Unexpected token (1:54)") is carried verbatim so the * model can see and fix it. */export class CodeCompilationError extends Data.TaggedError("CodeCompilationError")<{  readonly runtime: string;  readonly message: string;  readonly cause?: unknown;}> {} /** * Raised when the sandbox cannot run the user's code to completion for a * reason that is not a syntax error but is still safe and useful to * report back: the returned value is not serializable across the sandbox * boundary (a Symbol, a host object like `Cloudflare`), the code exceeded * the isolate's CPU or memory limit, or the sandbox is momentarily at * capacity. Like `CodeCompilationError`, and unlike `CodeExecutionError`, * this describes the user's own code or a transient, retryable condition * rather than an executor defect, so runtimes surface its verbatim * `message` through the descriptive `ExecuteResult.error` channel instead * of collapsing it to an opaque internal-error string. Genuinely * unexpected sandbox defects stay on `CodeExecutionError` and remain * opaque, preserving the host's failure-channel boundary. */export class SandboxRuntimeError extends Data.TaggedError("SandboxRuntimeError")<{  readonly runtime: string;  readonly message: string;  readonly cause?: unknown;}> {}