theokit 0.2.0 → 0.2.2

package/dist/{chunk-WQCPKA2L.js → chunk-C27AZN46.js}

@@ -317,11 +317,172 @@ function resolveTransformer(selector) {
   return selector;
 }
 
+// src/server/body-parser.ts
+import { basename } from "path";
+import Busboy from "busboy";
+var METHODS_WITH_BODY = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH"]);
+var DEFAULT_MAX_FILE_SIZE = 10 * 1024 * 1024;
+var DEFAULT_MAX_FILES = 10;
+var DEFAULT_MAX_FIELD_SIZE = 1 * 1024 * 1024;
+var FileTooLargeError = class extends Error {
+  constructor(message, truncatedFilenames, maxFileSize) {
+    super(message);
+    this.truncatedFilenames = truncatedFilenames;
+    this.maxFileSize = maxFileSize;
+    this.name = "FileTooLargeError";
+  }
+  truncatedFilenames;
+  maxFileSize;
+  code = "FILE_TOO_LARGE";
+  status = 413;
+};
+function stashBodyPreview(req, body) {
+  try {
+    ;
+    req[DEVTOOLS_BODY_PREVIEW] = body;
+  } catch {
+  }
+}
+function parseJsonBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => {
+      const raw = Buffer.concat(chunks).toString();
+      if (!raw) {
+        resolve(void 0);
+        return;
+      }
+      try {
+        resolve(JSON.parse(raw));
+      } catch {
+        reject(new Error("Invalid JSON body"));
+      }
+    });
+    req.on("error", reject);
+  });
+}
+function parseMultipartBody(req, contentType, options) {
+  if (!contentType.includes("boundary=")) {
+    return Promise.reject(new Error("Missing multipart boundary"));
+  }
+  return new Promise((resolve, reject) => {
+    const fields = {};
+    const files = [];
+    const truncatedFilenames = [];
+    let fileCount = 0;
+    const bb = Busboy({
+      headers: req.headers,
+      limits: {
+        fileSize: options.maxFileSize,
+        files: options.maxFiles,
+        fieldSize: options.maxFieldSize
+      }
+    });
+    bb.on("field", (name, value) => {
+      fields[name] = value;
+    });
+    bb.on(
+      "file",
+      (fieldname, stream, info) => {
+        fileCount++;
+        if (fileCount > options.maxFiles) {
+          stream.resume();
+          return;
+        }
+        const safeName = basename(info.filename || "unnamed");
+        const chunks = [];
+        let size = 0;
+        let truncated = false;
+        stream.on("data", (chunk) => {
+          size += chunk.length;
+          if (size > options.maxFileSize) {
+            truncated = true;
+            stream.resume();
+            return;
+          }
+          chunks.push(chunk);
+        });
+        stream.on("end", () => {
+          if (truncated) {
+            truncatedFilenames.push(safeName);
+            return;
+          }
+          const buffer = Buffer.concat(chunks);
+          files.push({
+            fieldname,
+            filename: safeName,
+            encoding: info.encoding,
+            mimeType: info.mimeType,
+            buffer,
+            size: buffer.length
+          });
+        });
+      }
+    );
+    bb.on("filesLimit", () => {
+      reject(new Error(`Too many files. Maximum: ${options.maxFiles}`));
+    });
+    bb.on("error", (err) => {
+      reject(err);
+    });
+    bb.on("close", () => {
+      if (truncatedFilenames.length > 0) {
+        reject(
+          new FileTooLargeError(
+            `File too large (max ${options.maxFileSize} bytes): ${truncatedFilenames.join(", ")}`,
+            truncatedFilenames,
+            options.maxFileSize
+          )
+        );
+        return;
+      }
+      resolve({ fields, files });
+    });
+    req.pipe(bb);
+  });
+}
+var DEVTOOLS_BODY_PREVIEW = /* @__PURE__ */ Symbol("theo:devtools:bodyPreview");
+async function parseRequestBody(req, options) {
+  const method = req.method?.toUpperCase() ?? "GET";
+  if (!METHODS_WITH_BODY.has(method)) {
+    return { fields: {}, files: [], json: void 0 };
+  }
+  const contentType = req.headers["content-type"] ?? "";
+  if (contentType.includes("application/json")) {
+    const json = await parseJsonBody(req);
+    stashBodyPreview(req, json);
+    return { fields: {}, files: [], json };
+  }
+  if (contentType.includes("multipart/form-data")) {
+    const limits = {
+      maxFileSize: options?.maxFileSize ?? DEFAULT_MAX_FILE_SIZE,
+      maxFiles: options?.maxFiles ?? DEFAULT_MAX_FILES,
+      maxFieldSize: options?.maxFieldSize ?? DEFAULT_MAX_FIELD_SIZE
+    };
+    const { fields, files } = await parseMultipartBody(req, contentType, limits);
+    stashBodyPreview(req, {
+      fields,
+      files: files.map((f) => ({
+        fieldname: f.fieldname,
+        filename: f.filename,
+        mimeType: f.mimeType,
+        size: f.size
+      }))
+    });
+    return { fields, files };
+  }
+  if (!contentType) {
+    return { fields: {}, files: [] };
+  }
+  throw new Error(`Unsupported Content-Type: ${contentType}`);
+}
+
 // src/server/observability/request-log.ts
 var defaultLoggerFn = (log) => {
   console.log(JSON.stringify(log));
 };
-function logRequest(info, customLogger) {
+function logRequest(info, customLogger, req) {
   const log = {
     level: "info",
     ...info,
@@ -329,13 +490,24 @@ function logRequest(info, customLogger) {
   };
   const logger = customLogger ?? defaultLoggerFn;
   logger(log);
-  broadcastRequestToDevtools(info);
+  broadcastRequestToDevtools(info, req);
 }
 function randomRequestId() {
   return `req-${String(Date.now())}-${Math.random().toString(36).slice(2, 8)}`;
 }
-function broadcastRequestToDevtools(info) {
-  void import("./broadcast-QOQGUNNK.js").then(({ broadcastRequest }) => {
+function broadcastRequestToDevtools(info, req) {
+  const headers = req?.headers ? Object.fromEntries(
+    Object.entries(req.headers).map(([k, v]) => [
+      k,
+      Array.isArray(v) ? v.join(", ") : v ?? ""
+    ])
+  ) : void 0;
+  const stashedBody = req ? req[DEVTOOLS_BODY_PREVIEW] : void 0;
+  void Promise.all([
+    import("./broadcast-QOQGUNNK.js"),
+    import("./build-request-body-preview-II2235E6.js")
+  ]).then(([{ broadcastRequest }, { buildRequestBodyPreview }]) => {
+    const bodyInfo = buildRequestBodyPreview(stashedBody);
     broadcastRequest({
       id: randomRequestId(),
       traceId: info.requestId,
@@ -343,7 +515,13 @@ function broadcastRequestToDevtools(info) {
       path: info.url,
       status: info.status,
       durationMs: info.duration,
-      startedAt: Date.now() - info.duration
+      startedAt: Date.now() - info.duration,
+      ...headers ? { headers } : {},
+      ...bodyInfo ? {
+        bodyPreview: bodyInfo.preview,
+        bodyLength: bodyInfo.length,
+        bodyTruncated: bodyInfo.truncated
+      } : {}
     });
   }).catch(() => {
   });
@@ -670,149 +848,6 @@ function enforceCsrf(req, mode, logger, disallowed, auditLogger) {
   return { allow: false, reason: check.reason };
 }
 
-// src/server/body-parser.ts
-import { basename } from "path";
-import Busboy from "busboy";
-var METHODS_WITH_BODY = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH"]);
-var DEFAULT_MAX_FILE_SIZE = 10 * 1024 * 1024;
-var DEFAULT_MAX_FILES = 10;
-var DEFAULT_MAX_FIELD_SIZE = 1 * 1024 * 1024;
-var FileTooLargeError = class extends Error {
-  constructor(message, truncatedFilenames, maxFileSize) {
-    super(message);
-    this.truncatedFilenames = truncatedFilenames;
-    this.maxFileSize = maxFileSize;
-    this.name = "FileTooLargeError";
-  }
-  truncatedFilenames;
-  maxFileSize;
-  code = "FILE_TOO_LARGE";
-  status = 413;
-};
-function parseJsonBody(req) {
-  return new Promise((resolve, reject) => {
-    const chunks = [];
-    req.on("data", (chunk) => chunks.push(chunk));
-    req.on("end", () => {
-      const raw = Buffer.concat(chunks).toString();
-      if (!raw) {
-        resolve(void 0);
-        return;
-      }
-      try {
-        resolve(JSON.parse(raw));
-      } catch {
-        reject(new Error("Invalid JSON body"));
-      }
-    });
-    req.on("error", reject);
-  });
-}
-function parseMultipartBody(req, contentType, options) {
-  if (!contentType.includes("boundary=")) {
-    return Promise.reject(new Error("Missing multipart boundary"));
-  }
-  return new Promise((resolve, reject) => {
-    const fields = {};
-    const files = [];
-    const truncatedFilenames = [];
-    let fileCount = 0;
-    const bb = Busboy({
-      headers: req.headers,
-      limits: {
-        fileSize: options.maxFileSize,
-        files: options.maxFiles,
-        fieldSize: options.maxFieldSize
-      }
-    });
-    bb.on("field", (name, value) => {
-      fields[name] = value;
-    });
-    bb.on(
-      "file",
-      (fieldname, stream, info) => {
-        fileCount++;
-        if (fileCount > options.maxFiles) {
-          stream.resume();
-          return;
-        }
-        const safeName = basename(info.filename || "unnamed");
-        const chunks = [];
-        let size = 0;
-        let truncated = false;
-        stream.on("data", (chunk) => {
-          size += chunk.length;
-          if (size > options.maxFileSize) {
-            truncated = true;
-            stream.resume();
-            return;
-          }
-          chunks.push(chunk);
-        });
-        stream.on("end", () => {
-          if (truncated) {
-            truncatedFilenames.push(safeName);
-            return;
-          }
-          const buffer = Buffer.concat(chunks);
-          files.push({
-            fieldname,
-            filename: safeName,
-            encoding: info.encoding,
-            mimeType: info.mimeType,
-            buffer,
-            size: buffer.length
-          });
-        });
-      }
-    );
-    bb.on("filesLimit", () => {
-      reject(new Error(`Too many files. Maximum: ${options.maxFiles}`));
-    });
-    bb.on("error", (err) => {
-      reject(err);
-    });
-    bb.on("close", () => {
-      if (truncatedFilenames.length > 0) {
-        reject(
-          new FileTooLargeError(
-            `File too large (max ${options.maxFileSize} bytes): ${truncatedFilenames.join(", ")}`,
-            truncatedFilenames,
-            options.maxFileSize
-          )
-        );
-        return;
-      }
-      resolve({ fields, files });
-    });
-    req.pipe(bb);
-  });
-}
-async function parseRequestBody(req, options) {
-  const method = req.method?.toUpperCase() ?? "GET";
-  if (!METHODS_WITH_BODY.has(method)) {
-    return { fields: {}, files: [], json: void 0 };
-  }
-  const contentType = req.headers["content-type"] ?? "";
-  if (contentType.includes("application/json")) {
-    const json = await parseJsonBody(req);
-    return { fields: {}, files: [], json };
-  }
-  if (contentType.includes("multipart/form-data")) {
-    const limits = {
-      maxFileSize: options?.maxFileSize ?? DEFAULT_MAX_FILE_SIZE,
-      maxFiles: options?.maxFiles ?? DEFAULT_MAX_FILES,
-      maxFieldSize: options?.maxFieldSize ?? DEFAULT_MAX_FIELD_SIZE
-    };
-    const { fields, files } = await parseMultipartBody(req, contentType, limits);
-    return { fields, files };
-  }
-  if (!contentType) {
-    return { fields: {}, files: [] };
-  }
-  throw new Error(`Unsupported Content-Type: ${contentType}`);
-}
-
 // src/server/http/execute-stages.ts
 async function parseQueryAndBody(req, res, requestId) {
   const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
@@ -1190,6 +1225,215 @@ async function executeRoute(ctx) {
   }
 }
 
+// src/core/contracts/action-protocol.ts
+var CODE_TO_STATUS = {
+  VALIDATION_ERROR: 422,
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  METHOD_NOT_ALLOWED: 405,
+  CONFLICT: 409,
+  CONTENT_TOO_LARGE: 413,
+  PAYLOAD_TOO_LARGE: 413,
+  UNSUPPORTED_MEDIA_TYPE: 415,
+  TOO_MANY_REQUESTS: 429,
+  INTERNAL_SERVER_ERROR: 500
+};
+var STATUS_TO_CODE = {
+  400: "BAD_REQUEST",
+  401: "UNAUTHORIZED",
+  403: "FORBIDDEN",
+  404: "NOT_FOUND",
+  405: "METHOD_NOT_ALLOWED",
+  409: "CONFLICT",
+  413: "PAYLOAD_TOO_LARGE",
+  415: "UNSUPPORTED_MEDIA_TYPE",
+  422: "VALIDATION_ERROR",
+  429: "TOO_MANY_REQUESTS",
+  500: "INTERNAL_SERVER_ERROR"
+};
+var ActionError = class _ActionError extends Error {
+  // Discriminator widened to the full union so subclasses can narrow to their
+  // specific literal (TypeScript would otherwise reject the override). Concrete
+  // values are still always exact literals at runtime.
+  type = "TheoActionError";
+  code;
+  status;
+  constructor(params) {
+    super(params.message ?? params.code);
+    this.code = params.code;
+    this.status = _ActionError.codeToStatus(params.code);
+    if (params.stack) {
+      this.stack = params.stack;
+    }
+  }
+  static codeToStatus(code) {
+    return CODE_TO_STATUS[code];
+  }
+  static statusToCode(status) {
+    return STATUS_TO_CODE[status] ?? "INTERNAL_SERVER_ERROR";
+  }
+  /**
+   * Parse a serialized error JSON back into the typed class hierarchy.
+   * Distinguishes `TheoActionInputError` (with `issues` array) from
+   * `TheoActionError` via the `type` discriminator. Falls back to
+   * `INTERNAL_SERVER_ERROR` for malformed bodies (non-object, missing
+   * `type`, unknown `code`).
+   */
+  static fromJson(body) {
+    if (typeof body !== "object" || body === null) {
+      return new _ActionError({ code: "INTERNAL_SERVER_ERROR" });
+    }
+    const obj = body;
+    if (obj.type === "TheoActionInputError" && Array.isArray(obj.issues)) {
+      return new ActionInputError(obj.issues);
+    }
+    if (obj.type === "TheoActionError" && typeof obj.code === "string" && obj.code in CODE_TO_STATUS) {
+      return new _ActionError({
+        code: obj.code,
+        message: typeof obj.message === "string" ? obj.message : void 0
+      });
+    }
+    return new _ActionError({ code: "INTERNAL_SERVER_ERROR" });
+  }
+};
+var ActionInputError = class extends ActionError {
+  type = "TheoActionInputError";
+  issues;
+  fields;
+  constructor(rawIssues) {
+    super({ code: "VALIDATION_ERROR", message: "Validation failed" });
+    this.issues = extractUniversalIssues(rawIssues);
+    this.fields = buildFieldsMap(this.issues);
+  }
+};
+function buildFieldsMap(issues) {
+  const fields = {};
+  const seen = /* @__PURE__ */ new Set();
+  for (const issue of issues) {
+    const key = issue.path.length === 0 ? "" : issue.path.join(".");
+    const dedupeKey = `${key}\0${issue.message}`;
+    if (seen.has(dedupeKey)) continue;
+    seen.add(dedupeKey);
+    const bucket = fields[key] ?? [];
+    bucket.push(issue.message);
+    fields[key] = bucket;
+  }
+  return fields;
+}
+function extractUniversalIssues(raw) {
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  for (const entry of raw) {
+    if (typeof entry !== "object" || entry === null) continue;
+    const obj = entry;
+    if (!Array.isArray(obj.path)) continue;
+    if (typeof obj.message !== "string") continue;
+    const path = [];
+    let pathValid = true;
+    for (const seg of obj.path) {
+      if (typeof seg === "string" || typeof seg === "number") {
+        path.push(seg);
+      } else {
+        pathValid = false;
+        break;
+      }
+    }
+    if (!pathValid) continue;
+    out.push({
+      path,
+      message: obj.message,
+      code: typeof obj.code === "string" ? obj.code : void 0
+    });
+  }
+  return out;
+}
+
+// src/server/http/form-data-to-object.ts
+import { z } from "zod";
+function formDataToObject(formData, schema, prefix = "") {
+  const shape = schema._def.shape();
+  const out = {};
+  for (const [key, rawValidator] of Object.entries(shape)) {
+    const fullKey = prefix + key;
+    const validator = unwrapWrappers(rawValidator);
+    if (validator instanceof z.ZodObject) {
+      const nestedPrefix = `${fullKey}.`;
+      const hasNestedKeys = [...formData.keys()].some((k) => k.startsWith(nestedPrefix));
+      if (hasNestedKeys) {
+        out[key] = formDataToObject(formData, validator, nestedPrefix);
+        continue;
+      }
+      out[key] = unwrapMissingDefault(rawValidator);
+      continue;
+    }
+    if (validator instanceof z.ZodArray) {
+      const values = formData.getAll(fullKey);
+      out[key] = coerceArrayElements(values, validator);
+      continue;
+    }
+    if (validator instanceof z.ZodBoolean) {
+      out[key] = coerceBoolean(formData, fullKey);
+      continue;
+    }
+    if (formData.has(fullKey)) {
+      const raw = formData.get(fullKey);
+      out[key] = coerceScalar(raw, validator);
+    } else {
+      out[key] = unwrapMissingDefault(rawValidator);
+    }
+  }
+  return out;
+}
+function unwrapWrappers(validator) {
+  let inner = validator;
+  while (inner instanceof z.ZodOptional || inner instanceof z.ZodNullable || inner instanceof z.ZodDefault) {
+    inner = inner._def.innerType;
+  }
+  return inner;
+}
+function unwrapMissingDefault(validator) {
+  let cursor = validator;
+  while (cursor instanceof z.ZodOptional || cursor instanceof z.ZodNullable || cursor instanceof z.ZodDefault) {
+    if (cursor instanceof z.ZodDefault) {
+      const def = cursor._def.defaultValue;
+      return typeof def === "function" ? def() : def;
+    }
+    if (cursor instanceof z.ZodNullable) return null;
+    cursor = cursor._def.innerType;
+  }
+  return void 0;
+}
+function coerceScalar(raw, validator) {
+  if (raw === null) return void 0;
+  if (validator instanceof z.ZodNumber) {
+    return typeof raw === "string" ? Number(raw) : raw;
+  }
+  return raw;
+}
+function coerceArrayElements(values, arrayValidator) {
+  const elementType = unwrapWrappers(arrayValidator._def.type);
+  if (elementType instanceof z.ZodNumber) {
+    return values.map((v) => typeof v === "string" ? Number(v) : v);
+  }
+  if (elementType instanceof z.ZodBoolean) {
+    return values.map((v) => {
+      if (v === "true") return true;
+      if (v === "false") return false;
+      return Boolean(v);
+    });
+  }
+  return values;
+}
+function coerceBoolean(formData, key) {
+  if (!formData.has(key)) return void 0;
+  const val = formData.get(key);
+  if (val === "true") return true;
+  if (val === "false") return false;
+  return Boolean(val);
+}
+
 // src/server/http/handle-request-error.ts
 async function handleRequestError(err, c) {
   if (c.pluginRunner) {
@@ -1235,7 +1479,78 @@ async function handleRequestError(err, c) {
   }
 }
 
+// src/server/http/serialize-action-result.ts
+import { stringify as devalueStringify } from "devalue";
+var DEFAULT_RESPONSE_BODY_SIZE_LIMIT = 5 * 1024 * 1024;
+function serializeActionResult(result, options = {}) {
+  const limit = options.responseBodySizeLimit ?? DEFAULT_RESPONSE_BODY_SIZE_LIMIT;
+  if (result.error !== void 0) {
+    const body2 = result.error instanceof ActionInputError ? JSON.stringify({
+      type: result.error.type,
+      code: result.error.code,
+      message: result.error.message,
+      issues: result.error.issues,
+      fields: result.error.fields
+    }) : JSON.stringify({
+      type: result.error.type,
+      code: result.error.code,
+      message: result.error.message
+    });
+    if (Buffer.byteLength(body2, "utf8") > limit) {
+      throw new ActionError({
+        code: "PAYLOAD_TOO_LARGE",
+        message: `Serialized error body exceeds limit (${limit} bytes)`
+      });
+    }
+    return {
+      type: "error",
+      status: result.error.status,
+      contentType: "application/json",
+      body: body2
+    };
+  }
+  if (result.data === void 0) {
+    return { type: "empty", status: 204 };
+  }
+  if (result.data instanceof Response) {
+    throw new ActionError({
+      code: "INTERNAL_SERVER_ERROR",
+      message: "Action handler cannot serialize Response objects \u2014 return plain data instead"
+    });
+  }
+  let body;
+  try {
+    body = devalueStringify(result.data, {
+      URL: (value) => value instanceof URL && value.href
+    });
+  } catch (e) {
+    throw new ActionError({
+      code: "INTERNAL_SERVER_ERROR",
+      message: `Action data not serializable: ${e instanceof Error ? e.message : String(e)}`
+    });
+  }
+  if (Buffer.byteLength(body, "utf8") > limit) {
+    throw new ActionError({
+      code: "PAYLOAD_TOO_LARGE",
+      message: `Serialized response body exceeds limit (${limit} bytes)`
+    });
+  }
+  return {
+    type: "data",
+    status: 200,
+    contentType: "application/json+devalue",
+    body
+  };
+}
+
 // src/server/http/action-execute.ts
+var __IS_DEV = (() => {
+  try {
+    return import.meta.env?.DEV === true;
+  } catch {
+    return process.env.NODE_ENV !== "production";
+  }
+})();
 function isActionConfig(value) {
   if (typeof value !== "object" || value === null) return false;
   const candidate = value;
@@ -1302,16 +1617,72 @@ async function runPreHandlerPipeline(p) {
   }
   return true;
 }
-async function readActionBody(req, res, requestId) {
+async function readActionBody(req, res, requestId, actionConfig) {
   try {
     const parsed = await parseRequestBody(req);
-    const body = parsed.json !== void 0 ? parsed.json : parsed.fields;
+    const accept = actionConfig.accept ?? "json";
+    let body;
+    if (accept === "form") {
+      body = formDataToObject(
+        synthesizeFormData(parsed),
+        actionConfig.input
+      );
+    } else if (parsed.json !== void 0) {
+      body = parsed.json;
+    } else {
+      body = parsed.fields;
+    }
     return { ok: true, body };
   } catch (err) {
     sendError(res, "VALIDATION_ERROR", err.message, 400, void 0, requestId);
     return { ok: false };
   }
 }
+function synthesizeFormData(parsed) {
+  const fd = new FormData();
+  for (const [name, value] of Object.entries(parsed.fields)) {
+    fd.append(name, value);
+  }
+  for (const file of parsed.files) {
+    const blob = new Blob([file.buffer], {
+      type: file.mimeType
+    });
+    fd.append(file.fieldname, blob, file.filename);
+  }
+  return fd;
+}
+function writeSerialized(res, serialized) {
+  if (serialized.type === "empty") {
+    res.statusCode = serialized.status;
+    res.end();
+    return;
+  }
+  res.statusCode = serialized.status;
+  res.setHeader("Content-Type", serialized.contentType);
+  res.end(serialized.body);
+}
+async function emitActionCallTelemetry(name, startedAt, input, outcome) {
+  if (!__IS_DEV) return;
+  try {
+    const mod = await import("./dispatcher-E6QV32BO.js");
+    mod.dispatcher.onActionCall({
+      // eslint-disable-next-line sonarjs/pseudo-random -- non-secret correlation id
+      id: `act-${String(Date.now())}-${Math.random().toString(36).slice(2, 8)}`,
+      timestamp: startedAt,
+      name,
+      input,
+      output: outcome.status === "success" ? outcome.output : void 0,
+      error: outcome.status === "error" ? {
+        code: outcome.error.code,
+        message: outcome.error.message,
+        fields: outcome.error instanceof ActionInputError ? outcome.error.fields : void 0
+      } : void 0,
+      durationMs: Date.now() - startedAt,
+      status: outcome.status
+    });
+  } catch {
+  }
+}
 async function executeActionWithOptions(opts) {
   const {
     filePath,
@@ -1358,22 +1729,24 @@ async function executeActionWithOptions(opts) {
     };
     if (!await runPreHandlerPipeline(pipeline)) return;
     ctx = pipeline.ctx;
-    const bodyOutcome = await readActionBody(req, res, requestId);
+    const bodyOutcome = await readActionBody(req, res, requestId, actionConfig);
     if (!bodyOutcome.ok) return;
+    const actionName = exportName === "default" ? deriveActionNameFromPath(filePath) : exportName;
+    const startedAt = Date.now();
     const result = actionConfig.input.safeParse(bodyOutcome.body);
     if (!result.success) {
-      sendError(
-        res,
-        "VALIDATION_ERROR",
-        "Invalid action input",
-        400,
-        result.error?.issues,
-        requestId
-      );
+      const inputErr = new ActionInputError(result.error?.issues ?? []);
+      writeSerialized(res, serializeActionResult({ data: void 0, error: inputErr }));
+      await emitActionCallTelemetry(actionName, startedAt, bodyOutcome.body, {
+        status: "error",
+        error: inputErr
+      });
       return;
     }
     await runActionHandler({
       actionConfig,
+      actionName,
+      startedAt,
       input: result.data,
       ctx,
       res,
@@ -1384,12 +1757,44 @@ async function executeActionWithOptions(opts) {
     await handleActionError(err, { req, res, ctx, requestId, pluginRunner, buildPluginCtx });
   }
 }
+function deriveActionNameFromPath(filePath) {
+  const base = filePath.split(/[\\/]/).pop() ?? "unknown";
+  return base.replace(/\.[jt]sx?$/, "");
+}
+function isActionErrorLike(err) {
+  if (err === null || typeof err !== "object") return false;
+  const obj = err;
+  return (obj.type === "TheoActionError" || obj.type === "TheoActionInputError") && typeof obj.code === "string" && typeof obj.status === "number";
+}
 async function runActionHandler(args) {
-  const handlerResult = await args.actionConfig.handler({ input: args.input, ctx: args.ctx });
-  const status = handlerResult === void 0 || handlerResult === null ? 204 : 200;
-  sendJson(args.res, handlerResult ?? null, status);
-  if (args.pluginRunner) {
-    await args.pluginRunner.runOnResponse(args.buildPluginCtx(args.ctx));
+  try {
+    const handlerResult = await args.actionConfig.handler({ input: args.input, ctx: args.ctx });
+    writeSerialized(args.res, serializeActionResult({ data: handlerResult, error: void 0 }));
+    if (args.pluginRunner) {
+      await args.pluginRunner.runOnResponse(args.buildPluginCtx(args.ctx));
+    }
+    await emitActionCallTelemetry(args.actionName, args.startedAt, args.input, {
+      status: "success",
+      output: handlerResult
+    });
+  } catch (err) {
+    if (isActionErrorLike(err)) {
+      writeSerialized(args.res, serializeActionResult({ data: void 0, error: err }));
+      await emitActionCallTelemetry(args.actionName, args.startedAt, args.input, {
+        status: "error",
+        error: err
+      });
+      return;
+    }
+    const wrapped = new ActionError({
+      code: "INTERNAL_SERVER_ERROR",
+      message: err instanceof Error ? err.message : "Action handler threw"
+    });
+    await emitActionCallTelemetry(args.actionName, args.startedAt, args.input, {
+      status: "error",
+      error: wrapped
+    });
+    throw err;
   }
 }
 async function handleActionError(err, c) {
@@ -1532,4 +1937,4 @@ export {
   resolveTransformer,
   generateNonce
 };
-//# sourceMappingURL=chunk-WQCPKA2L.js.map
+//# sourceMappingURL=chunk-C27AZN46.js.map