@executor-js/codemode-core 0.0.1-beta.0

package/dist/code-recovery.d.ts

@@ -0,0 +1,2 @@
+export declare const recoverExecutionBody: (code: string) => string;
+//# sourceMappingURL=code-recovery.d.ts.map

package/dist/code-recovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-recovery.d.ts","sourceRoot":"","sources":["../src/code-recovery.ts"],"names":[],"mappings":"AAuIA,eAAO,MAAM,oBAAoB,GAAI,MAAM,MAAM,KAAG,MASnD,CAAC"}

package/dist/code-recovery.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=code-recovery.test.d.ts.map

package/dist/code-recovery.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-recovery.test.d.ts","sourceRoot":"","sources":["../src/code-recovery.test.ts"],"names":[],"mappings":""}

package/dist/effect-errors.d.ts

@@ -0,0 +1,11 @@
+declare const KernelCoreEffectError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "KernelCoreEffectError";
+} & Readonly<A>;
+export declare class KernelCoreEffectError extends KernelCoreEffectError_base<{
+    readonly module: string;
+    readonly message: string;
+}> {
+}
+export declare const kernelCoreEffectError: (module: string, message: string) => KernelCoreEffectError;
+export {};
+//# sourceMappingURL=effect-errors.d.ts.map

package/dist/effect-errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect-errors.d.ts","sourceRoot":"","sources":["../src/effect-errors.ts"],"names":[],"mappings":";;;AAEA,qBAAa,qBAAsB,SAAQ,2BAA0C;IACnF,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B,CAAC;CAAG;AAEL,eAAO,MAAM,qBAAqB,GAAI,QAAQ,MAAM,EAAE,SAAS,MAAM,0BACrB,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./types";
+export * from "./validation";
+export * from "./json-schema";
+export * from "./effect-errors";
+export * from "./code-recovery";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC"}

package/dist/index.js

@@ -0,0 +1,227 @@
+// src/types.ts
+var asToolPath = (value) => value;
+var unknownInputSchema = {
+  "~standard": {
+    version: 1,
+    vendor: "@executor-js/codemode-core",
+    validate: (value) => ({
+      value
+    })
+  }
+};
+
+// src/validation.ts
+import * as Effect from "effect/Effect";
+
+// src/effect-errors.ts
+import * as Data from "effect/Data";
+var KernelCoreEffectError = class extends Data.TaggedError("KernelCoreEffectError") {
+};
+var kernelCoreEffectError = (module, message) => new KernelCoreEffectError({ module, message });
+
+// src/validation.ts
+var getSchemaValidator = (schema) => {
+  if (!schema || typeof schema !== "object" && typeof schema !== "function") {
+    return null;
+  }
+  const standard = schema["~standard"];
+  if (!standard || typeof standard !== "object") {
+    return null;
+  }
+  const validate = standard.validate;
+  return typeof validate === "function" ? validate : null;
+};
+var formatIssuePath = (path) => {
+  if (!path || path.length === 0) {
+    return "$";
+  }
+  return path.map(
+    (segment) => typeof segment === "object" && segment !== null && "key" in segment ? String(segment.key) : String(segment)
+  ).join(".");
+};
+var formatIssues = (issues) => issues.map((issue) => `${formatIssuePath(issue.path)}: ${issue.message}`).join("; ");
+var validateInput = (input) => {
+  const validate = getSchemaValidator(input.schema);
+  if (!validate) {
+    return Effect.fail(
+      kernelCoreEffectError(
+        "validation",
+        `Tool ${input.path} has no Standard Schema validator on inputSchema`
+      )
+    );
+  }
+  return Effect.tryPromise({
+    try: () => Promise.resolve(validate(input.value)),
+    catch: (cause) => kernelCoreEffectError("validation", `Validation error for ${input.path}: ${String(cause)}`)
+  }).pipe(
+    Effect.flatMap((result) => {
+      if ("issues" in result && result.issues) {
+        return Effect.fail(
+          kernelCoreEffectError(
+            "validation",
+            `Input validation failed for ${input.path}: ${formatIssues(result.issues)}`
+          )
+        );
+      }
+      return Effect.succeed(result.value);
+    })
+  );
+};
+
+// src/json-schema.ts
+import Ajv2020 from "ajv/dist/2020";
+import addFormats from "ajv-formats";
+var ajv = new Ajv2020({
+  allErrors: true,
+  strict: false,
+  validateSchema: false,
+  allowUnionTypes: true
+});
+addFormats(ajv);
+var decodePointerSegment = (segment) => {
+  const decoded = segment.replaceAll("~1", "/").replaceAll("~0", "~");
+  return /^\d+$/.test(decoded) ? Number(decoded) : decoded;
+};
+var pointerToPath = (pointer) => {
+  if (!pointer || pointer.length === 0 || pointer === "/") {
+    return void 0;
+  }
+  return pointer.split("/").slice(1).filter((segment) => segment.length > 0).map(decodePointerSegment);
+};
+var toIssueMessage = (error) => {
+  const keyword = error.keyword.trim();
+  const message = (error.message ?? "Invalid value").trim();
+  return keyword.length > 0 ? `${keyword}: ${message}` : message;
+};
+var standardSchemaFromJsonSchema = (schema, options) => {
+  try {
+    const validate = ajv.compile(schema);
+    return {
+      "~standard": {
+        version: 1,
+        vendor: options?.vendor ?? "json-schema",
+        validate: (value) => {
+          const valid = validate(value);
+          if (valid) {
+            return { value };
+          }
+          const issues = (validate.errors ?? []).map((error) => ({
+            message: toIssueMessage(error),
+            path: pointerToPath(error.instancePath)
+          }));
+          return {
+            issues: issues.length > 0 ? issues : [{ message: "Invalid value" }]
+          };
+        }
+      }
+    };
+  } catch {
+    return options?.fallback ?? unknownInputSchema;
+  }
+};
+
+// src/code-recovery.ts
+import { parse } from "@babel/parser";
+var FENCED_CODE_BLOCK = /```(?:[^\n`]*)?\s*\n([\s\S]*?)```/i;
+var FUNCTION_DECLARATION = /^(?:async\s+)?function(?:\s+([a-zA-Z_$][a-zA-Z0-9_$]*))?\s*\(/;
+var CALLABLE_ERROR = "Code must evaluate to a function";
+var extractCandidateSource = (code) => {
+  const trimmed = code.trim();
+  if (!trimmed) return "";
+  const fenced = trimmed.match(FENCED_CODE_BLOCK)?.[1];
+  return (fenced ?? trimmed).trim();
+};
+var wrapCallableBody = (source) => [
+  "const __fn = (",
+  source,
+  ");",
+  `if (typeof __fn !== "function") throw new Error(${JSON.stringify(CALLABLE_ERROR)});`,
+  "return await __fn();"
+].join("\n");
+var wrapNamedFunctionBody = (source, name) => [source, `return await ${name}();`].join("\n");
+var wrapAnonymousFunctionBody = (source) => `return await (${source})();`;
+var sliceNode = (source, node) => {
+  const start = node.start ?? 0;
+  const end = node.end ?? source.length;
+  return source.slice(start, end);
+};
+var unwrapExpression = (expression) => {
+  switch (expression.type) {
+    case "ParenthesizedExpression":
+    case "TSAsExpression":
+    case "TSSatisfiesExpression":
+    case "TSTypeAssertion":
+    case "TSNonNullExpression":
+    case "TSInstantiationExpression":
+      return expression.expression ? unwrapExpression(expression.expression) : expression;
+    default:
+      return expression;
+  }
+};
+var renderExportDefaultBody = (source, declaration) => {
+  if (declaration.type === "FunctionDeclaration") {
+    const fnSource = sliceNode(source, declaration);
+    const name = declaration.id?.name;
+    return name ? wrapNamedFunctionBody(fnSource, name) : wrapAnonymousFunctionBody(fnSource);
+  }
+  const expression = unwrapExpression(declaration);
+  const expressionSource = sliceNode(source, declaration);
+  if (expression?.type === "ArrowFunctionExpression" || expression?.type === "FunctionExpression") {
+    return wrapCallableBody(expressionSource);
+  }
+  return `return (${expressionSource});`;
+};
+var renderParsedBody = (source) => {
+  const program = parse(source, {
+    sourceType: "module",
+    allowAwaitOutsideFunction: true,
+    allowReturnOutsideFunction: true,
+    allowImportExportEverywhere: true,
+    plugins: ["typescript"]
+  }).program;
+  if (program.body.length !== 1) return source;
+  const [statement] = program.body;
+  if (!statement) return source;
+  switch (statement.type) {
+    case "ExpressionStatement": {
+      const expression = unwrapExpression(statement.expression);
+      return expression?.type === "ArrowFunctionExpression" || expression?.type === "FunctionExpression" ? wrapCallableBody(source) : source;
+    }
+    case "FunctionDeclaration":
+      return statement.id?.name ? wrapNamedFunctionBody(source, statement.id.name) : source;
+    case "ExportDefaultDeclaration":
+      return renderExportDefaultBody(source, statement.declaration);
+    default:
+      return source;
+  }
+};
+var renderHeuristicBody = (source) => {
+  const withoutDefaultExport = source.replace(/^export\s+default\s+/, "").trim();
+  if ((withoutDefaultExport.startsWith("async") || withoutDefaultExport.startsWith("(")) && withoutDefaultExport.includes("=>")) {
+    return wrapCallableBody(withoutDefaultExport);
+  }
+  if (FUNCTION_DECLARATION.test(withoutDefaultExport)) {
+    const name = withoutDefaultExport.match(FUNCTION_DECLARATION)?.[1];
+    return name ? wrapNamedFunctionBody(withoutDefaultExport, name) : wrapAnonymousFunctionBody(withoutDefaultExport);
+  }
+  return withoutDefaultExport;
+};
+var recoverExecutionBody = (code) => {
+  const source = extractCandidateSource(code);
+  if (!source) return "";
+  try {
+    return renderParsedBody(source);
+  } catch {
+    return renderHeuristicBody(source);
+  }
+};
+export {
+  KernelCoreEffectError,
+  asToolPath,
+  kernelCoreEffectError,
+  recoverExecutionBody,
+  standardSchemaFromJsonSchema,
+  unknownInputSchema,
+  validateInput
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types.ts","../src/validation.ts","../src/effect-errors.ts","../src/json-schema.ts","../src/code-recovery.ts"],"sourcesContent":["import type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport type * as Effect from \"effect/Effect\";\n\n/** Branded tool path */\nexport type ToolPath = string & { readonly __toolPath: unique symbol };\n\nexport const asToolPath = (value: string): ToolPath => value as ToolPath;\n\n/** Standard Schema alias */\nexport type StandardSchema<Input = unknown, Output = unknown> = StandardSchemaV1<Input, Output>;\n\n/** A tool that can be invoked */\nexport interface Tool {\n  readonly path: ToolPath;\n  readonly description?: string;\n  readonly inputSchema: StandardSchema;\n  readonly outputSchema?: StandardSchema;\n  readonly execute: (input: unknown) => unknown | Promise<unknown>;\n}\n\n/** Invoke a tool by path from inside a sandbox */\nexport interface SandboxToolInvoker {\n  invoke(input: { path: string; args: unknown }): Effect.Effect<unknown, unknown>;\n}\n\n/** Result of executing code in a sandbox */\nexport type ExecuteResult = {\n  result: unknown;\n  error?: string;\n  logs?: string[];\n};\n\n/** Executes code in a sandboxed runtime with tool access */\nexport interface CodeExecutor {\n  execute(code: string, toolInvoker: SandboxToolInvoker): Effect.Effect<ExecuteResult, unknown>;\n}\n\n/** Accept-anything schema for tools with no input validation */\nexport const unknownInputSchema: StandardSchema = {\n  \"~standard\": {\n    version: 1,\n    vendor: \"@executor/codemode-core\",\n    validate: (value: unknown) => ({\n      value,\n    }),\n  },\n};\n","import type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport * as Effect from \"effect/Effect\";\n\nimport { kernelCoreEffectError } from \"./effect-errors\";\n\nconst getSchemaValidator = (\n  schema: unknown,\n):\n  | ((\n      value: unknown,\n    ) => StandardSchemaV1.Result<unknown> | Promise<StandardSchemaV1.Result<unknown>>)\n  | null => {\n  if (!schema || (typeof schema !== \"object\" && typeof schema !== \"function\")) {\n    return null;\n  }\n\n  const standard = (schema as { \"~standard\"?: unknown })[\"~standard\"];\n  if (!standard || typeof standard !== \"object\") {\n    return null;\n  }\n\n  const validate = (standard as { validate?: unknown }).validate;\n  return typeof validate === \"function\"\n    ? (validate as (\n        value: unknown,\n      ) => StandardSchemaV1.Result<unknown> | Promise<StandardSchemaV1.Result<unknown>>)\n    : null;\n};\n\nconst formatIssuePath = (\n  path: ReadonlyArray<PropertyKey | StandardSchemaV1.PathSegment> | undefined,\n): string => {\n  if (!path || path.length === 0) {\n    return \"$\";\n  }\n\n  return path\n    .map((segment) =>\n      typeof segment === \"object\" && segment !== null && \"key\" in segment\n        ? String(segment.key)\n        : String(segment),\n    )\n    .join(\".\");\n};\n\nconst formatIssues = (issues: ReadonlyArray<StandardSchemaV1.Issue>): string =>\n  issues.map((issue) => `${formatIssuePath(issue.path)}: ${issue.message}`).join(\"; \");\n\n/** Validate a value against a Standard Schema */\nexport const validateInput = (input: {\n  schema: unknown;\n  value: unknown;\n  path: string;\n}): Effect.Effect<unknown, Error> => {\n  const validate = getSchemaValidator(input.schema);\n  if (!validate) {\n    return Effect.fail(\n      kernelCoreEffectError(\n        \"validation\",\n        `Tool ${input.path} has no Standard Schema validator on inputSchema`,\n      ),\n    );\n  }\n\n  return Effect.tryPromise({\n    try: () => Promise.resolve(validate(input.value)),\n    catch: (cause) =>\n      kernelCoreEffectError(\"validation\", `Validation error for ${input.path}: ${String(cause)}`),\n  }).pipe(\n    Effect.flatMap((result) => {\n      if (\"issues\" in result && result.issues) {\n        return Effect.fail(\n          kernelCoreEffectError(\n            \"validation\",\n            `Input validation failed for ${input.path}: ${formatIssues(result.issues)}`,\n          ),\n        );\n      }\n      return Effect.succeed(result.value);\n    }),\n  );\n};\n","import * as Data from \"effect/Data\";\n\nexport class KernelCoreEffectError extends Data.TaggedError(\"KernelCoreEffectError\")<{\n  readonly module: string;\n  readonly message: string;\n}> {}\n\nexport const kernelCoreEffectError = (module: string, message: string) =>\n  new KernelCoreEffectError({ module, message });\n","import type { ErrorObject } from \"ajv\";\nimport Ajv2020 from \"ajv/dist/2020\";\nimport addFormats from \"ajv-formats\";\n\nimport type { StandardSchema } from \"./types\";\nimport { unknownInputSchema } from \"./types\";\n\nconst ajv = new Ajv2020({\n  allErrors: true,\n  strict: false,\n  validateSchema: false,\n  allowUnionTypes: true,\n});\n\naddFormats(ajv);\n\nconst decodePointerSegment = (segment: string): PropertyKey => {\n  const decoded = segment.replaceAll(\"~1\", \"/\").replaceAll(\"~0\", \"~\");\n  return /^\\d+$/.test(decoded) ? Number(decoded) : decoded;\n};\n\nconst pointerToPath = (pointer: string | undefined): ReadonlyArray<PropertyKey> | undefined => {\n  if (!pointer || pointer.length === 0 || pointer === \"/\") {\n    return undefined;\n  }\n\n  return pointer\n    .split(\"/\")\n    .slice(1)\n    .filter((segment) => segment.length > 0)\n    .map(decodePointerSegment);\n};\n\nconst toIssueMessage = (error: ErrorObject): string => {\n  const keyword = error.keyword.trim();\n  const message = (error.message ?? \"Invalid value\").trim();\n  return keyword.length > 0 ? `${keyword}: ${message}` : message;\n};\n\nexport const standardSchemaFromJsonSchema = (\n  schema: unknown,\n  options?: {\n    vendor?: string;\n    fallback?: StandardSchema;\n  },\n): StandardSchema => {\n  try {\n    const validate = ajv.compile(schema as Record<string, unknown>);\n\n    return {\n      \"~standard\": {\n        version: 1,\n        vendor: options?.vendor ?? \"json-schema\",\n        validate: (value: unknown) => {\n          const valid = validate(value);\n          if (valid) {\n            return { value };\n          }\n\n          const issues = (validate.errors ?? []).map((error) => ({\n            message: toIssueMessage(error),\n            path: pointerToPath(error.instancePath),\n          }));\n\n          return {\n            issues: issues.length > 0 ? issues : [{ message: \"Invalid value\" }],\n          };\n        },\n      },\n    };\n  } catch {\n    return options?.fallback ?? unknownInputSchema;\n  }\n};\n","import { parse } from \"@babel/parser\";\n\nconst FENCED_CODE_BLOCK = /```(?:[^\\n`]*)?\\s*\\n([\\s\\S]*?)```/i;\nconst FUNCTION_DECLARATION =\n  /^(?:async\\s+)?function(?:\\s+([a-zA-Z_$][a-zA-Z0-9_$]*))?\\s*\\(/;\nconst CALLABLE_ERROR = \"Code must evaluate to a function\";\n\nconst extractCandidateSource = (code: string): string => {\n  const trimmed = code.trim();\n  if (!trimmed) return \"\";\n\n  const fenced = trimmed.match(FENCED_CODE_BLOCK)?.[1];\n  return (fenced ?? trimmed).trim();\n};\n\nconst wrapCallableBody = (source: string): string =>\n  [\n    \"const __fn = (\",\n    source,\n    \");\",\n    `if (typeof __fn !== \"function\") throw new Error(${JSON.stringify(CALLABLE_ERROR)});`,\n    \"return await __fn();\",\n  ].join(\"\\n\");\n\nconst wrapNamedFunctionBody = (source: string, name: string): string =>\n  [source, `return await ${name}();`].join(\"\\n\");\n\nconst wrapAnonymousFunctionBody = (source: string): string => `return await (${source})();`;\n\nconst sliceNode = (\n  source: string,\n  node: {\n    start?: number | null;\n    end?: number | null;\n  },\n): string => {\n  const start = node.start ?? 0;\n  const end = node.end ?? source.length;\n  return source.slice(start, end);\n};\n\nconst unwrapExpression = (expression: { type: string; expression?: unknown }): unknown => {\n  switch (expression.type) {\n    case \"ParenthesizedExpression\":\n    case \"TSAsExpression\":\n    case \"TSSatisfiesExpression\":\n    case \"TSTypeAssertion\":\n    case \"TSNonNullExpression\":\n    case \"TSInstantiationExpression\":\n      return expression.expression ? unwrapExpression(expression.expression as { type: string }) : expression;\n    default:\n      return expression;\n  }\n};\n\nconst renderExportDefaultBody = (\n  source: string,\n  declaration: {\n    type: string;\n    start?: number | null;\n    end?: number | null;\n    id?: { name?: string | null } | null;\n    expression?: unknown;\n  },\n): string => {\n  if (declaration.type === \"FunctionDeclaration\") {\n    const fnSource = sliceNode(source, declaration);\n    const name = declaration.id?.name;\n    return name ? wrapNamedFunctionBody(fnSource, name) : wrapAnonymousFunctionBody(fnSource);\n  }\n\n  const expression = unwrapExpression(declaration as { type: string; expression?: unknown }) as {\n    type?: string;\n  };\n  const expressionSource = sliceNode(source, declaration);\n\n  if (expression?.type === \"ArrowFunctionExpression\" || expression?.type === \"FunctionExpression\") {\n    return wrapCallableBody(expressionSource);\n  }\n\n  return `return (${expressionSource});`;\n};\n\nconst renderParsedBody = (source: string): string => {\n  const program = parse(source, {\n    sourceType: \"module\",\n    allowAwaitOutsideFunction: true,\n    allowReturnOutsideFunction: true,\n    allowImportExportEverywhere: true,\n    plugins: [\"typescript\"],\n  }).program;\n\n  if (program.body.length !== 1) return source;\n\n  const [statement] = program.body;\n  if (!statement) return source;\n\n  switch (statement.type) {\n    case \"ExpressionStatement\": {\n      const expression = unwrapExpression(statement.expression as { type: string; expression?: unknown }) as {\n        type?: string;\n      };\n      return expression?.type === \"ArrowFunctionExpression\" || expression?.type === \"FunctionExpression\"\n        ? wrapCallableBody(source)\n        : source;\n    }\n    case \"FunctionDeclaration\":\n      return statement.id?.name ? wrapNamedFunctionBody(source, statement.id.name) : source;\n    case \"ExportDefaultDeclaration\":\n      return renderExportDefaultBody(source, statement.declaration as never);\n    default:\n      return source;\n  }\n};\n\nconst renderHeuristicBody = (source: string): string => {\n  const withoutDefaultExport = source.replace(/^export\\s+default\\s+/, \"\").trim();\n\n  if (\n    (withoutDefaultExport.startsWith(\"async\") || withoutDefaultExport.startsWith(\"(\")) &&\n    withoutDefaultExport.includes(\"=>\")\n  ) {\n    return wrapCallableBody(withoutDefaultExport);\n  }\n\n  if (FUNCTION_DECLARATION.test(withoutDefaultExport)) {\n    const name = withoutDefaultExport.match(FUNCTION_DECLARATION)?.[1];\n    return name\n      ? wrapNamedFunctionBody(withoutDefaultExport, name)\n      : wrapAnonymousFunctionBody(withoutDefaultExport);\n  }\n\n  return withoutDefaultExport;\n};\n\nexport const recoverExecutionBody = (code: string): string => {\n  const source = extractCandidateSource(code);\n  if (!source) return \"\";\n\n  try {\n    return renderParsedBody(source);\n  } catch {\n    return renderHeuristicBody(source);\n  }\n};\n"],"mappings":";AAMO,IAAM,aAAa,CAAC,UAA4B;AAgChD,IAAM,qBAAqC;AAAA,EAChD,aAAa;AAAA,IACX,SAAS;AAAA,IACT,QAAQ;AAAA,IACR,UAAU,CAAC,WAAoB;AAAA,MAC7B;AAAA,IACF;AAAA,EACF;AACF;;;AC7CA,YAAY,YAAY;;;ACDxB,YAAY,UAAU;AAEf,IAAM,wBAAN,cAAyC,iBAAY,uBAAuB,EAGhF;AAAC;AAEG,IAAM,wBAAwB,CAAC,QAAgB,YACpD,IAAI,sBAAsB,EAAE,QAAQ,QAAQ,CAAC;;;ADH/C,IAAM,qBAAqB,CACzB,WAKU;AACV,MAAI,CAAC,UAAW,OAAO,WAAW,YAAY,OAAO,WAAW,YAAa;AAC3E,WAAO;AAAA,EACT;AAEA,QAAM,WAAY,OAAqC,WAAW;AAClE,MAAI,CAAC,YAAY,OAAO,aAAa,UAAU;AAC7C,WAAO;AAAA,EACT;AAEA,QAAM,WAAY,SAAoC;AACtD,SAAO,OAAO,aAAa,aACtB,WAGD;AACN;AAEA,IAAM,kBAAkB,CACtB,SACW;AACX,MAAI,CAAC,QAAQ,KAAK,WAAW,GAAG;AAC9B,WAAO;AAAA,EACT;AAEA,SAAO,KACJ;AAAA,IAAI,CAAC,YACJ,OAAO,YAAY,YAAY,YAAY,QAAQ,SAAS,UACxD,OAAO,QAAQ,GAAG,IAClB,OAAO,OAAO;AAAA,EACpB,EACC,KAAK,GAAG;AACb;AAEA,IAAM,eAAe,CAAC,WACpB,OAAO,IAAI,CAAC,UAAU,GAAG,gBAAgB,MAAM,IAAI,CAAC,KAAK,MAAM,OAAO,EAAE,EAAE,KAAK,IAAI;AAG9E,IAAM,gBAAgB,CAAC,UAIO;AACnC,QAAM,WAAW,mBAAmB,MAAM,MAAM;AAChD,MAAI,CAAC,UAAU;AACb,WAAc;AAAA,MACZ;AAAA,QACE;AAAA,QACA,QAAQ,MAAM,IAAI;AAAA,MACpB;AAAA,IACF;AAAA,EACF;AAEA,SAAc,kBAAW;AAAA,IACvB,KAAK,MAAM,QAAQ,QAAQ,SAAS,MAAM,KAAK,CAAC;AAAA,IAChD,OAAO,CAAC,UACN,sBAAsB,cAAc,wBAAwB,MAAM,IAAI,KAAK,OAAO,KAAK,CAAC,EAAE;AAAA,EAC9F,CAAC,EAAE;AAAA,IACM,eAAQ,CAAC,WAAW;AACzB,UAAI,YAAY,UAAU,OAAO,QAAQ;AACvC,eAAc;AAAA,UACZ;AAAA,YACE;AAAA,YACA,+BAA+B,MAAM,IAAI,KAAK,aAAa,OAAO,MAAM,CAAC;AAAA,UAC3E;AAAA,QACF;AAAA,MACF;AACA,aAAc,eAAQ,OAAO,KAAK;AAAA,IACpC,CAAC;AAAA,EACH;AACF;;;AEhFA,OAAO,aAAa;AACpB,OAAO,gBAAgB;AAKvB,IAAM,MAAM,IAAI,QAAQ;AAAA,EACtB,WAAW;AAAA,EACX,QAAQ;AAAA,EACR,gBAAgB;AAAA,EAChB,iBAAiB;AACnB,CAAC;AAED,WAAW,GAAG;AAEd,IAAM,uBAAuB,CAAC,YAAiC;AAC7D,QAAM,UAAU,QAAQ,WAAW,MAAM,GAAG,EAAE,WAAW,MAAM,GAAG;AAClE,SAAO,QAAQ,KAAK,OAAO,IAAI,OAAO,OAAO,IAAI;AACnD;AAEA,IAAM,gBAAgB,CAAC,YAAwE;AAC7F,MAAI,CAAC,WAAW,QAAQ,WAAW,KAAK,YAAY,KAAK;AACvD,WAAO;AAAA,EACT;AAEA,SAAO,QACJ,MAAM,GAAG,EACT,MAAM,CAAC,EACP,OAAO,CAAC,YAAY,QAAQ,SAAS,CAAC,EACtC,IAAI,oBAAoB;AAC7B;AAEA,IAAM,iBAAiB,CAAC,UAA+B;AACrD,QAAM,UAAU,MAAM,QAAQ,KAAK;AACnC,QAAM,WAAW,MAAM,WAAW,iBAAiB,KAAK;AACxD,SAAO,QAAQ,SAAS,IAAI,GAAG,OAAO,KAAK,OAAO,KAAK;AACzD;AAEO,IAAM,+BAA+B,CAC1C,QACA,YAImB;AACnB,MAAI;AACF,UAAM,WAAW,IAAI,QAAQ,MAAiC;AAE9D,WAAO;AAAA,MACL,aAAa;AAAA,QACX,SAAS;AAAA,QACT,QAAQ,SAAS,UAAU;AAAA,QAC3B,UAAU,CAAC,UAAmB;AAC5B,gBAAM,QAAQ,SAAS,KAAK;AAC5B,cAAI,OAAO;AACT,mBAAO,EAAE,MAAM;AAAA,UACjB;AAEA,gBAAM,UAAU,SAAS,UAAU,CAAC,GAAG,IAAI,CAAC,WAAW;AAAA,YACrD,SAAS,eAAe,KAAK;AAAA,YAC7B,MAAM,cAAc,MAAM,YAAY;AAAA,UACxC,EAAE;AAEF,iBAAO;AAAA,YACL,QAAQ,OAAO,SAAS,IAAI,SAAS,CAAC,EAAE,SAAS,gBAAgB,CAAC;AAAA,UACpE;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,EACF,QAAQ;AACN,WAAO,SAAS,YAAY;AAAA,EAC9B;AACF;;;ACzEA,SAAS,aAAa;AAEtB,IAAM,oBAAoB;AAC1B,IAAM,uBACJ;AACF,IAAM,iBAAiB;AAEvB,IAAM,yBAAyB,CAAC,SAAyB;AACvD,QAAM,UAAU,KAAK,KAAK;AAC1B,MAAI,CAAC,QAAS,QAAO;AAErB,QAAM,SAAS,QAAQ,MAAM,iBAAiB,IAAI,CAAC;AACnD,UAAQ,UAAU,SAAS,KAAK;AAClC;AAEA,IAAM,mBAAmB,CAAC,WACxB;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA,mDAAmD,KAAK,UAAU,cAAc,CAAC;AAAA,EACjF;AACF,EAAE,KAAK,IAAI;AAEb,IAAM,wBAAwB,CAAC,QAAgB,SAC7C,CAAC,QAAQ,gBAAgB,IAAI,KAAK,EAAE,KAAK,IAAI;AAE/C,IAAM,4BAA4B,CAAC,WAA2B,iBAAiB,MAAM;AAErF,IAAM,YAAY,CAChB,QACA,SAIW;AACX,QAAM,QAAQ,KAAK,SAAS;AAC5B,QAAM,MAAM,KAAK,OAAO,OAAO;AAC/B,SAAO,OAAO,MAAM,OAAO,GAAG;AAChC;AAEA,IAAM,mBAAmB,CAAC,eAAgE;AACxF,UAAQ,WAAW,MAAM;AAAA,IACvB,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AACH,aAAO,WAAW,aAAa,iBAAiB,WAAW,UAA8B,IAAI;AAAA,IAC/F;AACE,aAAO;AAAA,EACX;AACF;AAEA,IAAM,0BAA0B,CAC9B,QACA,gBAOW;AACX,MAAI,YAAY,SAAS,uBAAuB;AAC9C,UAAM,WAAW,UAAU,QAAQ,WAAW;AAC9C,UAAM,OAAO,YAAY,IAAI;AAC7B,WAAO,OAAO,sBAAsB,UAAU,IAAI,IAAI,0BAA0B,QAAQ;AAAA,EAC1F;AAEA,QAAM,aAAa,iBAAiB,WAAqD;AAGzF,QAAM,mBAAmB,UAAU,QAAQ,WAAW;AAEtD,MAAI,YAAY,SAAS,6BAA6B,YAAY,SAAS,sBAAsB;AAC/F,WAAO,iBAAiB,gBAAgB;AAAA,EAC1C;AAEA,SAAO,WAAW,gBAAgB;AACpC;AAEA,IAAM,mBAAmB,CAAC,WAA2B;AACnD,QAAM,UAAU,MAAM,QAAQ;AAAA,IAC5B,YAAY;AAAA,IACZ,2BAA2B;AAAA,IAC3B,4BAA4B;AAAA,IAC5B,6BAA6B;AAAA,IAC7B,SAAS,CAAC,YAAY;AAAA,EACxB,CAAC,EAAE;AAEH,MAAI,QAAQ,KAAK,WAAW,EAAG,QAAO;AAEtC,QAAM,CAAC,SAAS,IAAI,QAAQ;AAC5B,MAAI,CAAC,UAAW,QAAO;AAEvB,UAAQ,UAAU,MAAM;AAAA,IACtB,KAAK,uBAAuB;AAC1B,YAAM,aAAa,iBAAiB,UAAU,UAAoD;AAGlG,aAAO,YAAY,SAAS,6BAA6B,YAAY,SAAS,uBAC1E,iBAAiB,MAAM,IACvB;AAAA,IACN;AAAA,IACA,KAAK;AACH,aAAO,UAAU,IAAI,OAAO,sBAAsB,QAAQ,UAAU,GAAG,IAAI,IAAI;AAAA,IACjF,KAAK;AACH,aAAO,wBAAwB,QAAQ,UAAU,WAAoB;AAAA,IACvE;AACE,aAAO;AAAA,EACX;AACF;AAEA,IAAM,sBAAsB,CAAC,WAA2B;AACtD,QAAM,uBAAuB,OAAO,QAAQ,wBAAwB,EAAE,EAAE,KAAK;AAE7E,OACG,qBAAqB,WAAW,OAAO,KAAK,qBAAqB,WAAW,GAAG,MAChF,qBAAqB,SAAS,IAAI,GAClC;AACA,WAAO,iBAAiB,oBAAoB;AAAA,EAC9C;AAEA,MAAI,qBAAqB,KAAK,oBAAoB,GAAG;AACnD,UAAM,OAAO,qBAAqB,MAAM,oBAAoB,IAAI,CAAC;AACjE,WAAO,OACH,sBAAsB,sBAAsB,IAAI,IAChD,0BAA0B,oBAAoB;AAAA,EACpD;AAEA,SAAO;AACT;AAEO,IAAM,uBAAuB,CAAC,SAAyB;AAC5D,QAAM,SAAS,uBAAuB,IAAI;AAC1C,MAAI,CAAC,OAAQ,QAAO;AAEpB,MAAI;AACF,WAAO,iBAAiB,MAAM;AAAA,EAChC,QAAQ;AACN,WAAO,oBAAoB,MAAM;AAAA,EACnC;AACF;","names":[]}

package/dist/json-schema.d.ts

@@ -0,0 +1,6 @@
+import type { StandardSchema } from "./types";
+export declare const standardSchemaFromJsonSchema: (schema: unknown, options?: {
+    vendor?: string;
+    fallback?: StandardSchema;
+}) => StandardSchema;
+//# sourceMappingURL=json-schema.d.ts.map

package/dist/json-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-schema.d.ts","sourceRoot":"","sources":["../src/json-schema.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAmC9C,eAAO,MAAM,4BAA4B,GACvC,QAAQ,OAAO,EACf,UAAU;IACR,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,cAAc,CAAC;CAC3B,KACA,cA4BF,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,37 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+import type * as Effect from "effect/Effect";
+/** Branded tool path */
+export type ToolPath = string & {
+    readonly __toolPath: unique symbol;
+};
+export declare const asToolPath: (value: string) => ToolPath;
+/** Standard Schema alias */
+export type StandardSchema<Input = unknown, Output = unknown> = StandardSchemaV1<Input, Output>;
+/** A tool that can be invoked */
+export interface Tool {
+    readonly path: ToolPath;
+    readonly description?: string;
+    readonly inputSchema: StandardSchema;
+    readonly outputSchema?: StandardSchema;
+    readonly execute: (input: unknown) => unknown | Promise<unknown>;
+}
+/** Invoke a tool by path from inside a sandbox */
+export interface SandboxToolInvoker {
+    invoke(input: {
+        path: string;
+        args: unknown;
+    }): Effect.Effect<unknown, unknown>;
+}
+/** Result of executing code in a sandbox */
+export type ExecuteResult = {
+    result: unknown;
+    error?: string;
+    logs?: string[];
+};
+/** Executes code in a sandboxed runtime with tool access */
+export interface CodeExecutor {
+    execute(code: string, toolInvoker: SandboxToolInvoker): Effect.Effect<ExecuteResult, unknown>;
+}
+/** Accept-anything schema for tools with no input validation */
+export declare const unknownInputSchema: StandardSchema;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAC;AAE7C,wBAAwB;AACxB,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG;IAAE,QAAQ,CAAC,UAAU,EAAE,OAAO,MAAM,CAAA;CAAE,CAAC;AAEvE,eAAO,MAAM,UAAU,GAAI,OAAO,MAAM,KAAG,QAA6B,CAAC;AAEzE,4BAA4B;AAC5B,MAAM,MAAM,cAAc,CAAC,KAAK,GAAG,OAAO,EAAE,MAAM,GAAG,OAAO,IAAI,gBAAgB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;AAEhG,iCAAiC;AACjC,MAAM,WAAW,IAAI;IACnB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,WAAW,EAAE,cAAc,CAAC;IACrC,QAAQ,CAAC,YAAY,CAAC,EAAE,cAAc,CAAC;IACvC,QAAQ,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAClE;AAED,kDAAkD;AAClD,MAAM,WAAW,kBAAkB;IACjC,MAAM,CAAC,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,OAAO,CAAA;KAAE,GAAG,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;CACjF;AAED,4CAA4C;AAC5C,MAAM,MAAM,aAAa,GAAG;IAC1B,MAAM,EAAE,OAAO,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;CACjB,CAAC;AAEF,4DAA4D;AAC5D,MAAM,WAAW,YAAY;IAC3B,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,kBAAkB,GAAG,MAAM,CAAC,MAAM,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC;CAC/F;AAED,gEAAgE;AAChE,eAAO,MAAM,kBAAkB,EAAE,cAQhC,CAAC"}

package/dist/validation.d.ts

@@ -0,0 +1,8 @@
+import * as Effect from "effect/Effect";
+/** Validate a value against a Standard Schema */
+export declare const validateInput: (input: {
+    schema: unknown;
+    value: unknown;
+    path: string;
+}) => Effect.Effect<unknown, Error>;
+//# sourceMappingURL=validation.d.ts.map

package/dist/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AA+CxC,iDAAiD;AACjD,eAAO,MAAM,aAAa,GAAI,OAAO;IACnC,MAAM,EAAE,OAAO,CAAC;IAChB,KAAK,EAAE,OAAO,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd,KAAG,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,KAAK,CA4B/B,CAAC"}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@executor-js/codemode-core",
+  "version": "0.0.1-beta.0",
+  "homepage": "https://github.com/RhysSullivan/executor/tree/main/packages/kernel/core",
+  "bugs": {
+    "url": "https://github.com/RhysSullivan/executor/issues"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/RhysSullivan/executor.git",
+    "directory": "packages/kernel/core"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup && (tsc --declaration --emitDeclarationOnly --outDir dist --rootDir src || true)",
+    "typecheck": "tsgo --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck:slow": "bunx tsc --noEmit -p tsconfig.json"
+  },
+  "dependencies": {
+    "@babel/parser": "^7.29.2",
+    "@standard-schema/spec": "^1.0.0",
+    "ajv": "^8.17.1",
+    "ajv-formats": "^3.0.1",
+    "effect": "^3.21.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.3.1",
+    "bun-types": "^1.2.22",
+    "tsup": "^8.5.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.3"
+  }
+}