effect-codemode 0.0.1 → 0.1.0-beta.0

package/dist/testing.js

@@ -0,0 +1,890 @@
+// src/testing.ts
+import { Effect as Effect4, Layer as Layer3 } from "effect";
+
+// src/bridge.ts
+import { Effect, Exit, Runtime, Schedule, Schema } from "effect";
+
+// src/sanitize.ts
+var JS_RESERVED = new Set([
+  "break",
+  "case",
+  "catch",
+  "class",
+  "const",
+  "continue",
+  "debugger",
+  "default",
+  "delete",
+  "do",
+  "else",
+  "enum",
+  "export",
+  "extends",
+  "false",
+  "finally",
+  "for",
+  "function",
+  "if",
+  "import",
+  "in",
+  "instanceof",
+  "let",
+  "new",
+  "null",
+  "return",
+  "super",
+  "switch",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "typeof",
+  "undefined",
+  "var",
+  "void",
+  "while",
+  "with",
+  "yield",
+  "await",
+  "static",
+  "implements",
+  "interface",
+  "package",
+  "private",
+  "protected",
+  "public"
+]);
+function sanitizeToolName(name) {
+  let result = name.replace(/[-.\s]/g, "_");
+  result = result.replace(/[^a-zA-Z0-9_$]/g, "");
+  if (result.length === 0)
+    return "_";
+  if (/^\d/.test(result)) {
+    result = `_${result}`;
+  }
+  if (JS_RESERVED.has(result)) {
+    result = `${result}_`;
+  }
+  return result;
+}
+
+// src/bridge.ts
+var OptionTypeId = Symbol.for("effect/Option");
+var EitherTypeId = Symbol.for("effect/Either");
+var unwrapEffectTypes = (value, seen) => {
+  if (value === null || value === undefined || typeof value !== "object") {
+    return value;
+  }
+  const obj = value;
+  const tracking = seen ?? new WeakSet;
+  if (tracking.has(obj)) {
+    return "[Circular]";
+  }
+  tracking.add(obj);
+  if (OptionTypeId in obj) {
+    if (obj["_tag"] === "None") {
+      return null;
+    }
+    if (obj["_tag"] === "Some") {
+      return unwrapEffectTypes(obj["value"], tracking);
+    }
+  }
+  if (EitherTypeId in obj) {
+    if (obj["_tag"] === "Right") {
+      return unwrapEffectTypes(obj["right"], tracking);
+    }
+    if (obj["_tag"] === "Left") {
+      return { _tag: "Left", left: unwrapEffectTypes(obj["left"], tracking) };
+    }
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => unwrapEffectTypes(item, tracking));
+  }
+  const result = {};
+  for (const key of Object.keys(obj)) {
+    result[key] = unwrapEffectTypes(obj[key], tracking);
+  }
+  return result;
+};
+var MAX_RETRIES = 3;
+var isRateLimitError = (err) => {
+  if (typeof err !== "object" || err === null)
+    return false;
+  const obj = err;
+  if (obj["_tag"] === "RateLimitError")
+    return true;
+  if (obj["status"] === 429)
+    return true;
+  return false;
+};
+var backoff = (attempt, retryAfterSeconds) => {
+  const ms = retryAfterSeconds !== undefined ? retryAfterSeconds * 1000 : Math.pow(2, attempt) * 1000;
+  return new Promise((resolve) => setTimeout(resolve, ms));
+};
+var applyMiddleware = (middlewares, invocation, base) => {
+  let current = base;
+  for (let i = middlewares.length - 1;i >= 0; i--) {
+    const mw = middlewares[i];
+    const next = current;
+    current = mw(invocation, next);
+  }
+  return current;
+};
+var effectToAsyncFn = (tool, runtime, options) => {
+  const shouldValidateOutput = options?.validateOutput !== false;
+  const middlewares = options?.middleware ?? [];
+  return async (rawInput) => {
+    const decoded = Schema.decodeUnknownSync(tool.inputSchema)(rawInput);
+    let lastError;
+    for (let attempt = 0;attempt <= MAX_RETRIES; attempt++) {
+      if (attempt > 0) {
+        const retryAfter = isRateLimitError(lastError) ? lastError.retryAfter : undefined;
+        await backoff(attempt - 1, retryAfter);
+      }
+      let effect = tool.execute(decoded);
+      if (middlewares.length > 0) {
+        const invocation = { name: tool.name, input: decoded };
+        const provided = Effect.provide(effect, runtime.context);
+        effect = applyMiddleware(middlewares, invocation, provided);
+      }
+      const exit = await Runtime.runPromiseExit(runtime)(effect);
+      if (Exit.isSuccess(exit)) {
+        const unwrapped = unwrapEffectTypes(exit.value);
+        if (shouldValidateOutput && tool.outputSchema) {
+          try {
+            Schema.decodeUnknownSync(tool.outputSchema, {
+              onExcessProperty: "preserve"
+            })(unwrapped);
+          } catch (e) {
+            console.warn(`[codemode] Output validation warning for tool "${tool.name}":`, e instanceof Error ? e.message : String(e));
+          }
+        }
+        return unwrapped;
+      }
+      const cause = exit.cause;
+      const failure = cause._tag === "Fail" ? cause.error : cause;
+      const error = {
+        _tag: typeof failure === "object" && failure !== null && "_tag" in failure ? failure._tag : "ExecutionError",
+        message: typeof failure === "object" && failure !== null && "message" in failure ? failure.message : String(failure)
+      };
+      if (typeof failure === "object" && failure !== null) {
+        for (const [k, v] of Object.entries(failure)) {
+          if (k !== "_tag" && k !== "message") {
+            error[k] = v;
+          }
+        }
+      }
+      if (isRateLimitError(error) && attempt < MAX_RETRIES) {
+        lastError = error;
+        continue;
+      }
+      throw error;
+    }
+    throw lastError;
+  };
+};
+var effectToEffectFn = (tool, runtime, options) => {
+  const shouldValidateOutput = options?.validateOutput !== false;
+  const middlewares = options?.middleware ?? [];
+  return (rawInput) => {
+    const decoded = Schema.decodeUnknownSync(tool.inputSchema)(rawInput);
+    const baseEffect = Effect.flatMap(Effect.provide(tool.execute(decoded), runtime.context), (value) => {
+      const unwrapped = unwrapEffectTypes(value);
+      if (shouldValidateOutput && tool.outputSchema) {
+        try {
+          Schema.decodeUnknownSync(tool.outputSchema, {
+            onExcessProperty: "preserve"
+          })(unwrapped);
+        } catch (e) {
+          console.warn(`[codemode] Output validation warning for tool "${tool.name}":`, e instanceof Error ? e.message : String(e));
+        }
+      }
+      return Effect.succeed(unwrapped);
+    });
+    const withMiddleware = middlewares.length > 0 ? applyMiddleware(middlewares, { name: tool.name, input: decoded }, baseEffect) : baseEffect;
+    const retrySchedule = Schedule.exponential("1 second").pipe(Schedule.compose(Schedule.recurs(MAX_RETRIES)));
+    return withMiddleware.pipe(Effect.retry({
+      schedule: retrySchedule,
+      while: (err) => isRateLimitError(err)
+    }));
+  };
+};
+var buildEffectFnTable = (tools, runtime, options) => {
+  const table = {};
+  for (const tool of tools) {
+    const fn = effectToEffectFn(tool, runtime, options);
+    const key = sanitizeToolName(tool.name);
+    table[key] = (...args) => fn(args[0]);
+  }
+  return table;
+};
+
+// src/typegen.ts
+import { Option } from "effect";
+import * as SchemaAST from "effect/SchemaAST";
+function astToTypeScript(ast, seen = new Set) {
+  switch (ast._tag) {
+    case "StringKeyword":
+      return "string";
+    case "NumberKeyword":
+      return "number";
+    case "BooleanKeyword":
+      return "boolean";
+    case "BigIntKeyword":
+      return "bigint";
+    case "UndefinedKeyword":
+      return "undefined";
+    case "VoidKeyword":
+      return "void";
+    case "NeverKeyword":
+      return "never";
+    case "UnknownKeyword":
+      return "unknown";
+    case "AnyKeyword":
+      return "any";
+    case "ObjectKeyword":
+      return "object";
+    case "SymbolKeyword":
+      return "symbol";
+    case "UniqueSymbol":
+      return `typeof ${String(ast.symbol)}`;
+    case "Literal": {
+      if (ast.literal === null)
+        return "null";
+      if (typeof ast.literal === "string")
+        return JSON.stringify(ast.literal);
+      return String(ast.literal);
+    }
+    case "Enums":
+      return ast.enums.map(([_, v]) => JSON.stringify(v)).join(" | ") || "never";
+    case "TemplateLiteral": {
+      const spans = ast.spans.map((s) => {
+        const t = s.type._tag === "StringKeyword" ? "string" : s.type._tag === "NumberKeyword" ? "number" : astToTypeScript(s.type, seen);
+        return `\${${t}}${s.literal}`;
+      }).join("");
+      return `\`${ast.head}${spans}\``;
+    }
+    case "Union":
+      return ast.types.map((t) => astToTypeScript(t, seen)).join(" | ");
+    case "TupleType": {
+      const elems = ast.elements.map((e) => {
+        const t = astToTypeScript(e.type, seen);
+        return e.isOptional ? `${t}?` : t;
+      });
+      if (ast.rest.length > 0) {
+        const restType = astToTypeScript(ast.rest[0].type, seen);
+        if (ast.elements.length === 0)
+          return `Array<${restType}>`;
+        elems.push(`...Array<${restType}>`);
+      }
+      return `[${elems.join(", ")}]`;
+    }
+    case "TypeLiteral": {
+      if (ast.propertySignatures.length === 0 && ast.indexSignatures.length === 0) {
+        return "{}";
+      }
+      const props = ast.propertySignatures.map((ps) => {
+        const key = typeof ps.name === "string" ? /^[a-zA-Z_$][\w$]*$/.test(ps.name) ? ps.name : JSON.stringify(ps.name) : `[${String(ps.name)}]`;
+        const opt = ps.isOptional ? "?" : "";
+        return `  ${key}${opt}: ${astToTypeScript(ps.type, seen)}`;
+      });
+      const idxSigs = ast.indexSignatures.map((is) => {
+        const param = astToTypeScript(is.parameter, seen);
+        return `  [key: ${param}]: ${astToTypeScript(is.type, seen)}`;
+      });
+      return `{
+${[...props, ...idxSigs].join(`
+`)}
+}`;
+    }
+    case "Refinement":
+      return astToTypeScript(ast.from, seen);
+    case "Transformation":
+      return astToTypeScript(ast.to, seen);
+    case "Suspend": {
+      const id = Option.getOrUndefined(SchemaAST.getIdentifierAnnotation(ast));
+      if (id)
+        return id;
+      if (seen.has(ast))
+        return "unknown";
+      seen.add(ast);
+      return astToTypeScript(ast.f(), seen);
+    }
+    case "Declaration": {
+      const id = Option.getOrUndefined(SchemaAST.getIdentifierAnnotation(ast));
+      return id ?? "unknown";
+    }
+    default:
+      return "unknown";
+  }
+}
+function toPascalCase(name) {
+  return name.split(/[-_]/).map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("");
+}
+function fieldDescription(ast) {
+  const direct = Option.getOrUndefined(SchemaAST.getDescriptionAnnotation(ast));
+  if (direct)
+    return direct;
+  if (ast._tag === "Union") {
+    for (const member of ast.types) {
+      if (member._tag === "UndefinedKeyword")
+        continue;
+      const desc = Option.getOrUndefined(SchemaAST.getDescriptionAnnotation(member));
+      if (desc)
+        return desc;
+    }
+  }
+  return;
+}
+function resolveTypeLiteral(ast) {
+  if (ast._tag === "Transformation")
+    return ast.to;
+  return ast;
+}
+function buildJSDoc(description, inputAst, errors) {
+  const lines = [`/** ${description}`];
+  if (inputAst) {
+    const resolved = resolveTypeLiteral(inputAst);
+    if (resolved._tag === "TypeLiteral") {
+      for (const ps of resolved.propertySignatures) {
+        const desc = fieldDescription(ps.type);
+        if (desc)
+          lines.push(` * @param ${String(ps.name)} - ${desc}`);
+      }
+    }
+  }
+  if (errors && errors.length > 0) {
+    for (const err of errors) {
+      const tag = errorTag(err);
+      lines.push(` * @error ${tag} — catchable with Effect.catchTag("${tag}", ...)`);
+    }
+  }
+  lines.push(" */");
+  return lines.join(`
+`);
+}
+function errorTag(error) {
+  return typeof error === "string" ? error : error.tag;
+}
+function buildErrorType(error) {
+  const tag = errorTag(error);
+  if (typeof error === "string") {
+    return `type ${tag} = { readonly _tag: "${tag}"; readonly message: string }`;
+  }
+  const typeString = astToTypeScript(error.ast);
+  return `type ${tag} = ${typeString}`;
+}
+function resolveSharedOutputName(ast, firstToolKey) {
+  if (ast) {
+    const id = Option.getOrUndefined(SchemaAST.getIdentifierAnnotation(ast));
+    if (id)
+      return id;
+    if (ast._tag === "Transformation") {
+      const toId = Option.getOrUndefined(SchemaAST.getIdentifierAnnotation(ast.to));
+      if (toId)
+        return toId;
+    }
+  }
+  return `${toPascalCase(sanitizeToolName(firstToolKey))}Output`;
+}
+function generateDeclarations(tools) {
+  const entries = Object.entries(tools);
+  const outputTypeStringToGroup = new Map;
+  const toolOutputTypeName = new Map;
+  for (const [key, tool] of entries) {
+    const typeString = tool.outputSchema ? astToTypeScript(tool.outputSchema) : "unknown";
+    const existing = outputTypeStringToGroup.get(typeString);
+    if (existing) {
+      existing.keys.push(key);
+    } else {
+      outputTypeStringToGroup.set(typeString, { name: "", keys: [key] });
+    }
+  }
+  for (const [_typeString, group] of outputTypeStringToGroup) {
+    if (group.keys.length > 1) {
+      const firstTool = tools[group.keys[0]];
+      group.name = resolveSharedOutputName(firstTool.outputSchema, group.keys[0]);
+    } else {
+      const key = group.keys[0];
+      group.name = `${toPascalCase(sanitizeToolName(key))}Output`;
+    }
+    for (const key of group.keys) {
+      toolOutputTypeName.set(key, group.name);
+    }
+  }
+  const parts = [];
+  const methods = [];
+  const emittedErrors = new Set;
+  const emittedOutputTypes = new Set;
+  for (const [key, tool] of entries) {
+    const safeName = sanitizeToolName(key);
+    const pascal = toPascalCase(safeName);
+    const inputType = `${pascal}Input`;
+    const outputType = toolOutputTypeName.get(key);
+    parts.push(`type ${inputType} = ${astToTypeScript(tool.inputSchema)}`);
+    if (!emittedOutputTypes.has(outputType)) {
+      emittedOutputTypes.add(outputType);
+      const typeString = tool.outputSchema ? astToTypeScript(tool.outputSchema) : "unknown";
+      parts.push(`type ${outputType} = ${typeString}`);
+    }
+    if (tool.errors && tool.errors.length > 0) {
+      for (const err of tool.errors) {
+        const tag = errorTag(err);
+        if (!emittedErrors.has(tag)) {
+          emittedErrors.add(tag);
+          parts.push(buildErrorType(err));
+        }
+      }
+    }
+    const errorType = tool.errors && tool.errors.length > 0 ? tool.errors.map((e) => errorTag(e)).join(" | ") : "never";
+    const jsdoc = buildJSDoc(tool.description, tool.inputSchema, tool.errors);
+    methods.push(`  ${jsdoc}
+  ${safeName}(input: ${inputType}): Effect<${outputType}, ${errorType}>`);
+  }
+  parts.push("");
+  parts.push(`declare const codemode: {
+${methods.join(`
+`)}
+}`);
+  return parts.join(`
+
+`);
+}
+
+// src/types.ts
+function toTypegenDescriptor(tool) {
+  return {
+    name: tool.name,
+    description: tool.description,
+    inputSchema: tool.inputSchema.ast,
+    outputSchema: tool.outputSchema ? tool.outputSchema.ast : undefined,
+    errors: tool.errors
+  };
+}
+
+// src/codemode.ts
+function buildExamplesBlock(tools, max = 3) {
+  const withExamples = Object.entries(tools).filter(([_, t]) => t.example);
+  if (withExamples.length === 0)
+    return "";
+  const seen = new Set;
+  const picked = [];
+  for (const [key, tool] of withExamples) {
+    const svc = tool.service ?? "unknown";
+    if (!seen.has(svc) && picked.length < max) {
+      seen.add(svc);
+      picked.push([key, tool]);
+    }
+  }
+  for (const entry of withExamples) {
+    if (picked.length >= max)
+      break;
+    if (!picked.includes(entry)) {
+      picked.push(entry);
+    }
+  }
+  const lines = picked.map(([key, tool]) => `**${key}:**
+\`\`\`typescript
+${tool.example}
+\`\`\``);
+  return `
+
+Examples:
+
+${lines.join(`
+
+`)}`;
+}
+var COMPACT_THRESHOLD = 7;
+function createCodemodeTool(sandboxTools, runtime, executor, serviceStatuses, middleware, groupNames) {
+  const typegenTools = {};
+  for (const [key, tool] of Object.entries(sandboxTools)) {
+    typegenTools[key] = toTypegenDescriptor(tool);
+  }
+  const declarations = generateDeclarations(typegenTools);
+  const tools = Object.values(sandboxTools);
+  const fns = buildEffectFnTable(tools, runtime, { middleware });
+  const statusBlock = serviceStatuses ? `
+Service status:
+${serviceStatuses}
+` : "";
+  const serviceList = groupNames && groupNames.length > 0 ? groupNames.join(", ") : "configured services";
+  const examplesBlock = buildExamplesBlock(sandboxTools);
+  const toolCount = Object.keys(sandboxTools).length;
+  const isCompact = toolCount > COMPACT_THRESHOLD;
+  let apiBlock;
+  if (isCompact) {
+    const catalog = Object.entries(sandboxTools).map(([key, tool]) => `  ${key}(input): ${tool.description}`).join(`
+`);
+    apiBlock = `Available API (${toolCount} tools — use \`search_tools\` for full type signatures):
+
+${catalog}`;
+  } else {
+    apiBlock = `Available API:
+
+\`\`\`typescript
+${declarations}
+\`\`\``;
+  }
+  const description = `Execute TypeScript code using Effect to orchestrate operations across ${serviceList}.
+
+The sandbox has \`Effect\`, \`pipe\`, \`Duration\`, \`Schedule\`, \`Option\`, \`Either\`, \`Match\`, \`Schema\`, \`Arr\` (Effect's Array module), \`Ref\`, \`Stream\`, \`Chunk\`, \`Data\`, \`Order\`, and \`Predicate\` available as globals.
+Each method on \`codemode\` returns an \`Effect\` — use \`yield*\` inside \`Effect.gen\` to unwrap values.
+Return an Effect as the final value and the runtime will execute it.
+${statusBlock}
+
+${apiBlock}
+
+Write an \`Effect.gen\` program that calls methods on the \`codemode\` object using \`yield*\`.
+Return a value from the generator to send results back.
+${examplesBlock}
+
+**Error handling with catchTag** — gracefully catch service-specific errors:
+\`\`\`typescript
+Effect.gen(function* () {
+  return yield* codemode.some_tool({ id: "nonexistent" })
+}).pipe(
+  Effect.catchTag("NotFoundError", (e) => Effect.succeed({ error: e.message }))
+)
+\`\`\`
+
+**Retry with backoff** — retry a flaky operation:
+\`\`\`typescript
+Effect.gen(function* () {
+  return yield* codemode.some_tool({ id: "ID" })
+}).pipe(
+  Effect.retry({ times: 3, schedule: Schedule.exponential("1 second") })
+)
+\`\`\`
+
+**Timeout** — bail if an operation takes too long:
+\`\`\`typescript
+Effect.gen(function* () {
+  return yield* codemode.some_tool({})
+}).pipe(
+  Effect.timeout("10 seconds")
+)
+\`\`\`
+
+**Backward compatibility** — async/await still works:
+\`\`\`typescript
+async () => {
+  const result = await Effect.runPromise(codemode.some_tool({}))
+  return result
+}
+\`\`\``;
+  return {
+    name: "execute_code",
+    description,
+    declarations,
+    execute: (code, options) => executor.execute(code, fns, options)
+  };
+}
+
+// src/executor.ts
+import * as vm from "node:vm";
+import { Context, Layer } from "effect";
+
+// src/executor-base.ts
+import * as acorn from "acorn";
+import {
+  Array as Arr,
+  Chunk,
+  Data,
+  Duration,
+  Effect as Effect2,
+  Either,
+  Match,
+  Option as Option2,
+  Order,
+  Predicate,
+  Ref,
+  Schedule as Schedule2,
+  Schema as Schema2,
+  Stream,
+  pipe
+} from "effect";
+var EffectTypeId = Symbol.for("effect/Effect");
+var DEFAULT_TIMEOUT_MS = 30000;
+var stripTypeScript = (() => {
+  const g = globalThis;
+  if (typeof g["Bun"] === "object" && g["Bun"] !== null) {
+    const BunNs = g["Bun"];
+    const transpiler = new BunNs.Transpiler({ loader: "ts" });
+    const WRAP_PREFIX = "var __codemode__ = ";
+    return (code) => {
+      try {
+        const wrapped = `${WRAP_PREFIX}${code}`;
+        const result = transpiler.transformSync(wrapped).trim();
+        if (result.startsWith(WRAP_PREFIX)) {
+          let body = result.slice(WRAP_PREFIX.length);
+          if (body.endsWith(";"))
+            body = body.slice(0, -1);
+          return body.trim();
+        }
+      } catch {
+      }
+      try {
+        return transpiler.transformSync(code).trim();
+      } catch {
+        return code;
+      }
+    };
+  }
+  return (code) => code;
+})();
+var _globals = globalThis;
+var _fetch = _globals["fetch"];
+var _setTimeout = _globals["setTimeout"];
+var _clearTimeout = _globals["clearTimeout"];
+var _URL = _globals["URL"];
+var _Response = _globals["Response"];
+var _Request = _globals["Request"];
+var _Headers = _globals["Headers"];
+var _Promise = _globals["Promise"];
+function parallel(fns) {
+  return _Promise.all(fns.map((fn) => fn()));
+}
+function sleep(ms) {
+  return new _Promise((resolve) => _setTimeout(resolve, ms));
+}
+function isEffect(value) {
+  return typeof value === "object" && value !== null && EffectTypeId in value;
+}
+function normalizeCode(code) {
+  const trimmed = code.trim();
+  const stripped = stripTypeScript(trimmed);
+  const jsCode = stripped || trimmed;
+  try {
+    const ast = acorn.parse(jsCode, { ecmaVersion: 2022, sourceType: "module" });
+    const body = ast.body;
+    if (body.length === 0) {
+      return `return (async () => { ${jsCode} })()`;
+    }
+    const first = body[0];
+    if (body.length === 1 && first.type === "ExpressionStatement") {
+      const expr = first.expression;
+      if (expr.type === "ArrowFunctionExpression") {
+        const arrowExpr = jsCode.slice(expr.start, expr.end);
+        return `return (${arrowExpr})()`;
+      }
+    }
+    const last = body[body.length - 1];
+    if (last.type === "ExpressionStatement") {
+      const before = jsCode.slice(0, last.start);
+      const expr = jsCode.slice(last.start, last.end);
+      const cleanExpr = expr.replace(/;\s*$/, "");
+      return `return (async () => { ${before}return ${cleanExpr} })()`;
+    }
+    return `return (async () => { ${jsCode} })()`;
+  } catch {
+    return normalizeCodeFallback(jsCode);
+  }
+}
+function normalizeCodeFallback(code) {
+  if (isArrowFallback(code)) {
+    return `return (${code})()`;
+  }
+  return `return (async () => { ${code} })()`;
+}
+function isArrowFallback(code) {
+  if (/^async\s*\(/.test(code))
+    return true;
+  if (/^async\s+[a-zA-Z_$]\w*\s*=>/.test(code))
+    return true;
+  if (code.startsWith("(")) {
+    let depth = 0;
+    for (let i = 0;i < code.length; i++) {
+      if (code[i] === "(")
+        depth++;
+      else if (code[i] === ")") {
+        depth--;
+        if (depth === 0) {
+          const rest = code.slice(i + 1).trimStart();
+          return rest.startsWith("=>");
+        }
+      }
+    }
+  }
+  if (/^[a-zA-Z_$]\w*\s*=>/.test(code))
+    return true;
+  return false;
+}
+var networkBlockedFn = () => {
+  throw new Error("Network access is disabled (allowNetwork: false)");
+};
+var NetworkBlockedClass = new Proxy(class {
+}, {
+  construct() {
+    throw new Error("Network access is disabled (allowNetwork: false)");
+  },
+  apply() {
+    throw new Error("Network access is disabled (allowNetwork: false)");
+  }
+});
+function buildSandboxGlobals(fns, options, logs) {
+  const onLog = options?.onLog;
+  const emit = (level, msg) => {
+    logs.push(level === "log" ? msg : `[${level}] ${msg}`);
+    onLog?.(level, msg);
+  };
+  const capturedConsole = {
+    log: (...args) => emit("log", args.map(String).join(" ")),
+    warn: (...args) => emit("warn", args.map(String).join(" ")),
+    error: (...args) => emit("error", args.map(String).join(" ")),
+    info: (...args) => emit("info", args.map(String).join(" ")),
+    debug: (...args) => emit("debug", args.map(String).join(" "))
+  };
+  const allowNetwork = options?.allowNetwork !== false;
+  const globals = {
+    codemode: Object.freeze(fns),
+    console: Object.freeze(capturedConsole),
+    fetch: allowNetwork ? _fetch : networkBlockedFn,
+    setTimeout: _setTimeout,
+    clearTimeout: _clearTimeout,
+    URL: allowNetwork ? _URL : NetworkBlockedClass,
+    Response: allowNetwork ? _Response : NetworkBlockedClass,
+    Request: allowNetwork ? _Request : NetworkBlockedClass,
+    Headers: allowNetwork ? _Headers : NetworkBlockedClass,
+    Promise: _Promise,
+    parallel,
+    sleep,
+    Effect: Effect2,
+    pipe,
+    Duration,
+    Schedule: Schedule2,
+    Option: Option2,
+    Either,
+    Match,
+    Schema: Schema2,
+    Arr,
+    Ref,
+    Stream,
+    Chunk,
+    Data,
+    Order,
+    Predicate
+  };
+  return globals;
+}
+function createBaseExecutor(runCode) {
+  return {
+    execute: async (code, fns, options) => {
+      const logs = [];
+      const globals = buildSandboxGlobals(fns, options, logs);
+      try {
+        const trimmed = code.trim();
+        const wrappedCode = normalizeCode(trimmed);
+        const timeout = options?.["timeoutMs"] ?? DEFAULT_TIMEOUT_MS;
+        let result = await _Promise.race([
+          runCode(wrappedCode, globals),
+          new _Promise((_, reject) => _setTimeout(() => reject(new Error(`Execution timed out after ${timeout}ms`)), timeout))
+        ]);
+        if (isEffect(result)) {
+          result = await Effect2.runPromise(result);
+        }
+        return { result, logs };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { result: undefined, error: message, logs };
+      }
+    }
+  };
+}
+
+// src/executor.ts
+var createDirectExecutor = () => createBaseExecutor(async (wrappedCode, globals) => {
+  const paramNames = Object.keys(globals);
+  const paramValues = Object.values(globals);
+  const fn = new Function(...paramNames, wrappedCode);
+  return fn(...paramValues);
+});
+var createVmExecutor = () => createBaseExecutor(async (wrappedCode, globals) => {
+  const scriptCode = wrappedCode.startsWith("return ") ? wrappedCode.slice(7) : wrappedCode;
+  const context = vm.createContext(globals);
+  const script = new vm.Script(scriptCode);
+  return script.runInContext(context, { timeout: 35000 });
+});
+
+class CodeExecutor extends Context.Tag("@effect-codemode/Executor")() {
+  static Direct = Layer.succeed(CodeExecutor, createDirectExecutor());
+  static Vm = Layer.succeed(CodeExecutor, createVmExecutor());
+  static Default = CodeExecutor.Vm;
+}
+
+// src/registry.ts
+import { Context as Context2, Effect as Effect3, Layer as Layer2, Ref as Ref2 } from "effect";
+
+class CodemodeRegistry extends Context2.Tag("@effect-codemode/Registry")() {
+  static make = Effect3.gen(function* () {
+    const groupsRef = yield* Ref2.make([]);
+    const failedRef = yield* Ref2.make([]);
+    const globalMiddlewareRef = yield* Ref2.make([]);
+    return CodemodeRegistry.of({
+      registerGroup: (name, tools, middleware) => Ref2.update(groupsRef, (groups) => [...groups, { name, tools, middleware: middleware ?? [] }]),
+      registerFailure: (name, error) => Ref2.update(failedRef, (failed) => [...failed, { name, error }]),
+      registerMiddleware: (mw) => Ref2.update(globalMiddlewareRef, (mws) => [...mws, mw]),
+      snapshot: Effect3.all({
+        available: Ref2.get(groupsRef),
+        failed: Ref2.get(failedRef),
+        globalMiddleware: Ref2.get(globalMiddlewareRef)
+      })
+    });
+  });
+  static layer = Layer2.effect(CodemodeRegistry, CodemodeRegistry.make);
+}
+
+// src/testing.ts
+function snapshotGroups(groups) {
+  return Effect4.gen(function* () {
+    const registryImpl = yield* CodemodeRegistry.make;
+    const registryLayer = Layer3.succeed(CodemodeRegistry, registryImpl);
+    const mergedGroups = groups.length === 1 ? groups[0] : Layer3.mergeAll(...groups);
+    const fullLayer = Layer3.provide(mergedGroups, registryLayer);
+    yield* Layer3.build(fullLayer).pipe(Effect4.scoped);
+    const { available, failed } = yield* registryImpl.snapshot;
+    const allTools = {};
+    for (const group of available) {
+      for (const [key, tool] of Object.entries(group.tools)) {
+        allTools[key] = { ...tool, service: group.name };
+      }
+    }
+    const statusParts = [];
+    for (const g of available) {
+      statusParts.push(`  ${g.name}: available`);
+    }
+    for (const f of failed) {
+      statusParts.push(`  ${f.name}: unavailable (${f.error})`);
+    }
+    const statusText = statusParts.join(`
+`);
+    const groupNames = available.map((g) => g.name);
+    return { allTools, statusText, groupNames };
+  });
+}
+function buildTestTool(...groups) {
+  return Effect4.runSync(Effect4.gen(function* () {
+    const { allTools, statusText, groupNames } = yield* snapshotGroups(groups);
+    const rt = yield* Effect4.runtime();
+    const exec = yield* Effect4.provide(CodeExecutor, CodeExecutor.Default);
+    return createCodemodeTool(allTools, rt, exec, statusText, [], groupNames);
+  }));
+}
+function buildInspector(...groups) {
+  return Effect4.runSync(Effect4.gen(function* () {
+    const { allTools } = yield* snapshotGroups(groups);
+    const typegenTools = {};
+    for (const [key, tool] of Object.entries(allTools)) {
+      typegenTools[key] = toTypegenDescriptor(tool);
+    }
+    return generateDeclarations(typegenTools);
+  }));
+}
+export {
+  buildTestTool as test,
+  buildInspector as inspect,
+  buildTestTool,
+  buildInspector
+};
+
+//# debugId=5529472230DF2A5864756E2164756E21