@verbatra/studio 0.1.0-next.1

package/dist/index.js

@@ -0,0 +1,971 @@
+import { createServer } from 'http';
+import { fileURLToPath } from 'url';
+import { resolve, extname, normalize, join, sep, relative } from 'path';
+import { z } from 'zod';
+import { LOCK_FILE_NAME, lockState, diff, check } from '@verbatra/sdk';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import { readFile } from 'fs/promises';
+import { randomBytes, timingSafeEqual, createHash } from 'crypto';
+import { watch } from 'chokidar';
+
+// src/server/create-studio-server.ts
+
+// src/server/banner.ts
+function buildBanner(url, token) {
+  return `verbatra studio listening at ${url}?token=${token}`;
+}
+
+// src/server/cookie.ts
+var COOKIE_PREFIX = "verbatra_studio_";
+function cookieName(port) {
+  return `${COOKIE_PREFIX}${port}`;
+}
+function splitCookiePairs(header) {
+  return header.split(";").map((pair) => pair.trim());
+}
+function readCookieValue(header, name) {
+  if (header === void 0) {
+    return void 0;
+  }
+  for (const pair of splitCookiePairs(header)) {
+    const separatorIndex = pair.indexOf("=");
+    if (separatorIndex === -1) {
+      continue;
+    }
+    if (pair.slice(0, separatorIndex) === name) {
+      return pair.slice(separatorIndex + 1);
+    }
+  }
+  return void 0;
+}
+function buildSetCookieHeader(name, value) {
+  return `${name}=${value}; Path=/; HttpOnly; SameSite=Strict`;
+}
+
+// src/server/default-port.ts
+var DEFAULT_STUDIO_PORT = 5849;
+function resolvePort(port) {
+  return port ?? DEFAULT_STUDIO_PORT;
+}
+
+// src/server/body-reader.ts
+var BODY_CAP_BYTES = 1024 * 1024;
+var PayloadTooLargeError = class extends Error {
+  constructor() {
+    super("request body exceeds the size cap");
+    this.name = "PayloadTooLargeError";
+  }
+};
+function declaredLengthExceedsCap(request, capBytes) {
+  const header = request.headers["content-length"];
+  if (header === void 0) {
+    return false;
+  }
+  const declared = Number(header);
+  return Number.isFinite(declared) && declared > capBytes;
+}
+function readBodyWithCap(request, capBytes) {
+  return new Promise((resolve3, reject) => {
+    if (declaredLengthExceedsCap(request, capBytes)) {
+      request.resume();
+      reject(new PayloadTooLargeError());
+      return;
+    }
+    const chunks = [];
+    let total = 0;
+    let settled = false;
+    const settleReject = (error) => {
+      if (!settled) {
+        settled = true;
+        reject(error);
+      }
+    };
+    request.on("data", (chunk) => {
+      total += chunk.length;
+      if (total > capBytes) {
+        settled = true;
+        reject(new PayloadTooLargeError());
+        request.destroy();
+        return;
+      }
+      chunks.push(chunk);
+    });
+    request.on("end", () => {
+      settled = true;
+      resolve3(Buffer.concat(chunks));
+    });
+    request.on("error", settleReject);
+    request.on(
+      "close",
+      () => settleReject(new Error("request closed before the body was fully received"))
+    );
+  });
+}
+var CONTENT_TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".mjs": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".ico": "image/x-icon"
+};
+function contentTypeFor(assetPath) {
+  return CONTENT_TYPES[extname(assetPath)] ?? "application/octet-stream";
+}
+
+// src/server/host-origin.ts
+function isAllowedHost(hostHeader, port) {
+  if (hostHeader === void 0) {
+    return false;
+  }
+  return hostHeader.toLowerCase() === `127.0.0.1:${port}`;
+}
+function isAllowedOrigin(originHeader, port) {
+  if (originHeader === void 0) {
+    return true;
+  }
+  return originHeader === `http://127.0.0.1:${port}`;
+}
+
+// src/server/request-content-type.ts
+function isJsonRequestContentType(header) {
+  if (header === void 0) {
+    return false;
+  }
+  return header.trim().toLowerCase() === "application/json";
+}
+
+// src/server/request-log.ts
+function formatRequestLog(entry) {
+  return `${entry.method} ${entry.path} ${entry.status}`;
+}
+var STATUS_CHECK_METHOD = "status.check";
+var statusCheckParamsSchema = z.strictObject({
+  locales: z.array(z.string().min(1)).min(1).optional()
+});
+var STATUS_DIFF_METHOD = "status.diff";
+var statusDiffParamsSchema = z.strictObject({
+  locales: z.array(z.string().min(1)).min(1).optional()
+});
+var GLOSSARY_GET_METHOD = "glossary.get";
+var glossaryGetParamsSchema = z.strictObject({});
+var HISTORY_LIST_METHOD = "history.list";
+var historyListParamsSchema = z.strictObject({
+  limit: z.number().int().positive().optional()
+});
+var LOCK_STATE_METHOD = "lock.state";
+var lockStateParamsSchema = z.strictObject({});
+var PROJECT_SNAPSHOT_METHOD = "project.snapshot";
+var projectSnapshotParamsSchema = z.strictObject({});
+
+// src/shared/rpc/contract.ts
+var rpcParamsSchemas = {
+  [PROJECT_SNAPSHOT_METHOD]: projectSnapshotParamsSchema,
+  [STATUS_CHECK_METHOD]: statusCheckParamsSchema,
+  [STATUS_DIFF_METHOD]: statusDiffParamsSchema,
+  [GLOSSARY_GET_METHOD]: glossaryGetParamsSchema,
+  [LOCK_STATE_METHOD]: lockStateParamsSchema,
+  [HISTORY_LIST_METHOD]: historyListParamsSchema
+};
+var RPC_METHOD_NAMES = Object.keys(rpcParamsSchemas);
+
+// src/server/redaction.ts
+var REDACTED = "[REDACTED]";
+var KEY_PATTERNS = [
+  // The `\b` anchors `sk-` to a word start so hyphenated words like "risk-" or "task-" pass through.
+  /\bsk-[A-Za-z0-9_-]{8,}/g,
+  /AIza[0-9A-Za-z_-]{35}/g,
+  /[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}(?::fx)?/g
+];
+var PROVIDER_ENV_VAR_NAMES = [
+  "ANTHROPIC_API_KEY",
+  "OPENAI_API_KEY",
+  "GEMINI_API_KEY",
+  "DEEPL_API_KEY"
+];
+function escapeForRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function scrubConfiguredEnvValues(text) {
+  let out = text;
+  for (const name of PROVIDER_ENV_VAR_NAMES) {
+    const value = process.env[name];
+    if (value !== void 0 && value.length > 0) {
+      out = out.replace(new RegExp(escapeForRegExp(value), "g"), REDACTED);
+    }
+  }
+  return out;
+}
+function redact(text) {
+  let out = text;
+  for (const pattern of KEY_PATTERNS) {
+    out = out.replace(pattern, REDACTED);
+  }
+  return scrubConfiguredEnvValues(out);
+}
+var statusCheckHandler = async (params, deps) => check({
+  config: deps.config.config,
+  cwd: deps.projectRoot,
+  ...params.locales !== void 0 ? { locales: params.locales } : {}
+});
+var statusDiffHandler = async (params, deps) => diff({
+  config: deps.config.config,
+  cwd: deps.projectRoot,
+  ...params.locales !== void 0 ? { locales: params.locales } : {}
+});
+function projectConfigSource(source, projectRoot) {
+  if (source.kind === "override") {
+    return "override";
+  }
+  return redact(relative(projectRoot, source.filepath));
+}
+function projectGlossaryIndicator(glossary, projectRoot) {
+  if (glossary.source === "file") {
+    return { source: "file", path: redact(relative(projectRoot, glossary.path)) };
+  }
+  return { source: glossary.source };
+}
+function buildProjectSnapshot(loaded, projectRoot) {
+  const { config } = loaded;
+  return {
+    sourceLocale: redact(config.sourceLocale),
+    targetLocales: config.targetLocales.map((locale) => redact(locale)),
+    format: config.format,
+    files: { pattern: redact(config.files.pattern) },
+    provider: { id: config.provider.id },
+    configSource: projectConfigSource(loaded.source, projectRoot),
+    glossary: projectGlossaryIndicator(loaded.glossary, projectRoot),
+    ...config.prune !== void 0 ? { prune: config.prune } : {},
+    ...config.generatePlurals !== void 0 ? { generatePlurals: config.generatePlurals } : {},
+    ...config.maxBatchSize !== void 0 ? { maxBatchSize: config.maxBatchSize } : {},
+    ...config.tone !== void 0 ? { tone: config.tone } : {}
+  };
+}
+
+// src/server/methods/glossary.ts
+function redactGlossaryEntries(glossary) {
+  if (glossary === void 0) {
+    return {};
+  }
+  const redacted = {};
+  for (const [key, value] of Object.entries(glossary)) {
+    redacted[key] = redact(value);
+  }
+  return redacted;
+}
+var glossaryGetHandler = async (_params, deps) => ({
+  indicator: projectGlossaryIndicator(deps.config.glossary, deps.projectRoot),
+  entries: redactGlossaryEntries(deps.config.config.glossary)
+});
+function withoutTrailingSep(path) {
+  return path.length > sep.length && path.endsWith(sep) ? path.slice(0, -sep.length) : path;
+}
+
+// src/server/git.ts
+var execFileAsync = promisify(execFile);
+var defaultExecFileImpl = async (file, args, options) => {
+  const { stdout, stderr } = await execFileAsync(file, args, {
+    cwd: options.cwd,
+    encoding: "utf8"
+  });
+  return { stdout, stderr };
+};
+var HISTORY_LIMIT_DEFAULT = 50;
+var HISTORY_LIMIT_CAP = 200;
+function clampHistoryLimit(limit) {
+  return Math.min(limit ?? HISTORY_LIMIT_DEFAULT, HISTORY_LIMIT_CAP);
+}
+function isPathContained(root, candidate) {
+  const normalizedRoot = withoutTrailingSep(root);
+  return candidate === normalizedRoot || candidate.startsWith(normalizedRoot + sep);
+}
+function hasLeadingDash(path) {
+  return path.startsWith("-");
+}
+function resolveWatchedPaths(projectRoot, candidates) {
+  const root = resolve(projectRoot);
+  const safe = candidates.filter((candidate) => !hasLeadingDash(candidate)).map((candidate) => resolve(root, candidate)).filter((candidate) => isPathContained(root, candidate));
+  return Array.from(new Set(safe));
+}
+var RECORD_SEPARATOR = "";
+var FIELD_SEPARATOR = "";
+var GIT_LOG_FORMAT = `${RECORD_SEPARATOR}%H${FIELD_SEPARATOR}%aI${FIELD_SEPARATOR}%s`;
+function buildGitLogArgs(maxCount, paths) {
+  return [
+    "log",
+    `--max-count=${maxCount}`,
+    "--name-only",
+    "-z",
+    `--format=${GIT_LOG_FORMAT}`,
+    "--",
+    ...paths
+  ];
+}
+function parseCommitHeader(header) {
+  const [hash, authorDate, subject] = header.split(FIELD_SEPARATOR);
+  if (hash === void 0 || authorDate === void 0 || subject === void 0) {
+    return void 0;
+  }
+  return { hash, authorDate, subject };
+}
+function parseTouchedPaths(filesPart) {
+  return filesPart.split("\0").map((entry) => entry.startsWith("\n") ? entry.slice(1) : entry).filter((entry) => entry.length > 0);
+}
+function parseCommitRecord(record) {
+  const nulIndex = record.indexOf("\0");
+  const header = nulIndex === -1 ? record : record.slice(0, nulIndex);
+  const parsedHeader = parseCommitHeader(header);
+  if (parsedHeader === void 0) {
+    return void 0;
+  }
+  const touchedPaths = nulIndex === -1 ? [] : parseTouchedPaths(record.slice(nulIndex + 1));
+  return { ...parsedHeader, touchedPaths };
+}
+function parseGitLogOutput(stdout) {
+  return stdout.split(RECORD_SEPARATOR).filter((record) => record.length > 0).map(parseCommitRecord).filter((commit) => commit !== void 0);
+}
+function isMissingGitBinary(error) {
+  return error.code === "ENOENT";
+}
+function isNotARepository(error) {
+  return typeof error.stderr === "string" && error.stderr.includes("not a git repository");
+}
+function interpretGitLogFailure(error) {
+  const failure = error;
+  if (isMissingGitBinary(failure) || isNotARepository(failure)) {
+    return { available: false };
+  }
+  return { available: true, commits: [] };
+}
+async function runGitLog(input) {
+  if (input.watchedPaths.length === 0) {
+    return { available: true, commits: [] };
+  }
+  const args = buildGitLogArgs(clampHistoryLimit(input.limit), input.watchedPaths);
+  try {
+    const { stdout } = await input.execFileImpl("git", args, { cwd: input.projectRoot });
+    return { available: true, commits: parseGitLogOutput(stdout) };
+  } catch (error) {
+    return interpretGitLogFailure(error);
+  }
+}
+var LOCALE_TOKEN = "{locale}";
+function localeFilePath(cwd, pattern, locale) {
+  return resolve(cwd, pattern.replaceAll(LOCALE_TOKEN, locale));
+}
+
+// src/server/methods/history.ts
+function watchedLocalePaths(config, projectRoot) {
+  const locales = [config.sourceLocale, ...config.targetLocales];
+  return locales.map((locale) => localeFilePath(projectRoot, config.files.pattern, locale));
+}
+var historyListHandler = async (params, deps) => {
+  const execFileImpl = deps.execFileImpl ?? defaultExecFileImpl;
+  const candidates = watchedLocalePaths(deps.config.config, deps.projectRoot);
+  const watchedPaths = resolveWatchedPaths(deps.projectRoot, candidates);
+  return runGitLog({
+    execFileImpl,
+    projectRoot: deps.projectRoot,
+    watchedPaths,
+    ...params.limit !== void 0 ? { limit: params.limit } : {}
+  });
+};
+var lockStateHandler = async (_params, deps) => lockState({ config: deps.config.config, cwd: deps.projectRoot });
+
+// src/server/methods/snapshot.ts
+var snapshotHandler = async (_params, deps) => buildProjectSnapshot(deps.config, deps.projectRoot);
+
+// src/server/rpc.ts
+var rpcHandlers = {
+  [PROJECT_SNAPSHOT_METHOD]: snapshotHandler,
+  [STATUS_CHECK_METHOD]: statusCheckHandler,
+  [STATUS_DIFF_METHOD]: statusDiffHandler,
+  [GLOSSARY_GET_METHOD]: glossaryGetHandler,
+  [LOCK_STATE_METHOD]: lockStateHandler,
+  [HISTORY_LIST_METHOD]: historyListHandler
+};
+
+// src/server/rpc-gate.ts
+var REQUEST_INVALID_MESSAGE = "The request body must be JSON shaped as { method, params }.";
+var METHOD_UNKNOWN_MESSAGE = "The requested method is not recognized.";
+var PARAMS_INVALID_MESSAGE = "The request parameters failed validation.";
+var INTERNAL_ERROR_MESSAGE = "An unexpected error occurred.";
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseRequestShape(body) {
+  let parsed;
+  try {
+    parsed = JSON.parse(body.toString("utf8"));
+  } catch {
+    return void 0;
+  }
+  if (!isPlainObject(parsed)) {
+    return void 0;
+  }
+  const method = parsed.method;
+  if (typeof method !== "string") {
+    return void 0;
+  }
+  return { method, params: parsed.params };
+}
+function isKnownMethod(method) {
+  return RPC_METHOD_NAMES.includes(method);
+}
+function toParsedIssues(error) {
+  return error.issues.map((issue) => ({ path: issue.path.map(String), code: issue.code }));
+}
+function jsonEnvelope(statusCode, body) {
+  return { statusCode, body: JSON.stringify(body) };
+}
+function okEnvelope(result) {
+  return jsonEnvelope(200, { ok: true, result });
+}
+function errorEnvelope(statusCode, code, message, issues) {
+  const error = issues === void 0 ? { code, message } : { code, message, issues };
+  return jsonEnvelope(statusCode, { ok: false, error });
+}
+function isDomainError(error) {
+  return error instanceof Error && (error.name === "SdkError" || error.name === "AdapterError") && typeof error.code === "string";
+}
+function mapHandlerError(error) {
+  if (isDomainError(error)) {
+    return jsonEnvelope(200, {
+      ok: false,
+      error: { code: error.code, message: redact(error.message) }
+    });
+  }
+  return errorEnvelope(500, "INTERNAL", INTERNAL_ERROR_MESSAGE);
+}
+async function invokeHandler(method, params, deps, handlers) {
+  const schema = rpcParamsSchemas[method];
+  const parsedParams = schema.safeParse(params);
+  if (!parsedParams.success) {
+    return errorEnvelope(
+      400,
+      "PARAMS_INVALID",
+      PARAMS_INVALID_MESSAGE,
+      toParsedIssues(parsedParams.error)
+    );
+  }
+  const handler = handlers[method];
+  if (handler === void 0) {
+    return errorEnvelope(400, "METHOD_UNKNOWN", METHOD_UNKNOWN_MESSAGE);
+  }
+  try {
+    const result = await handler(parsedParams.data, deps);
+    return okEnvelope(result);
+  } catch (error) {
+    return mapHandlerError(error);
+  }
+}
+async function dispatchRpc(body, deps, handlers = rpcHandlers) {
+  const request = parseRequestShape(body);
+  if (request === void 0) {
+    return errorEnvelope(400, "REQUEST_INVALID", REQUEST_INVALID_MESSAGE);
+  }
+  if (!isKnownMethod(request.method)) {
+    return errorEnvelope(400, "METHOD_UNKNOWN", METHOD_UNKNOWN_MESSAGE);
+  }
+  return invokeHandler(request.method, request.params, deps, handlers);
+}
+function handleRpcBody(body, deps) {
+  return dispatchRpc(body, deps);
+}
+
+// src/server/security-headers.ts
+var CONTENT_SECURITY_POLICY = "default-src 'none'; script-src 'self'; style-src 'self'; img-src 'self' data:; font-src 'self'; connect-src 'self'; base-uri 'none'; form-action 'none'; frame-ancestors 'none'";
+function applySecurityHeaders(response) {
+  response.setHeader("X-Content-Type-Options", "nosniff");
+  response.setHeader("Referrer-Policy", "no-referrer");
+  response.setHeader("X-Frame-Options", "DENY");
+  response.setHeader("Content-Security-Policy", CONTENT_SECURITY_POLICY);
+}
+function applyNoStore(response) {
+  response.setHeader("Cache-Control", "no-store");
+}
+function decodeRequestPath(requestPath) {
+  try {
+    return decodeURIComponent(requestPath);
+  } catch {
+    return requestPath;
+  }
+}
+function hasDotSegment(pathWithoutLeadingSlash) {
+  return pathWithoutLeadingSlash.split("/").some((segment) => segment.startsWith("."));
+}
+function stripQuery(requestPath) {
+  const queryIndex = requestPath.indexOf("?");
+  return queryIndex === -1 ? requestPath : requestPath.slice(0, queryIndex);
+}
+function resolveAssetPath(assetsRootPath, requestPath) {
+  const root = withoutTrailingSep(normalize(assetsRootPath));
+  const decoded = decodeRequestPath(stripQuery(requestPath));
+  const withoutLeadingSlash = decoded.replace(/^\/+/, "");
+  if (hasDotSegment(withoutLeadingSlash)) {
+    return void 0;
+  }
+  const candidate = normalize(join(root, withoutLeadingSlash || "index.html"));
+  return candidate.startsWith(root + sep) ? candidate : void 0;
+}
+async function readAsset(assetsRootPath, requestPath) {
+  const resolved = resolveAssetPath(assetsRootPath, requestPath);
+  if (resolved === void 0) {
+    return void 0;
+  }
+  try {
+    const body = await readFile(resolved);
+    return { path: resolved, body };
+  } catch {
+    return void 0;
+  }
+}
+var TOKEN_BYTES = 32;
+function generateToken() {
+  return randomBytes(TOKEN_BYTES).toString("hex");
+}
+function hashToken(value) {
+  return createHash("sha256").update(value, "utf8").digest();
+}
+function tokensMatch(candidate, stored) {
+  return timingSafeEqual(hashToken(candidate), hashToken(stored));
+}
+
+// src/server/transport-responses.ts
+var UNAUTHORIZED_BODY = "Unauthorized";
+var FORBIDDEN_BODY = "Forbidden";
+var NOT_FOUND_BODY = "Not Found";
+var METHOD_NOT_ALLOWED_BODY = "Method Not Allowed";
+var PAYLOAD_TOO_LARGE_BODY = "Payload Too Large";
+var UNSUPPORTED_MEDIA_TYPE_BODY = "Unsupported Media Type";
+function sendConstantResponse(response, status, body) {
+  applyNoStore(response);
+  response.statusCode = status;
+  response.setHeader("Content-Type", "text/plain; charset=utf-8");
+  response.end(body);
+}
+
+// src/server/dispatch.ts
+var EVENTS_PATH = "/events";
+function pathWithoutQuery(url) {
+  const index = url.indexOf("?");
+  return index === -1 ? url : url.slice(0, index);
+}
+function extractBootstrapToken(url) {
+  const index = url.indexOf("?");
+  if (index === -1) {
+    return void 0;
+  }
+  const params = new URLSearchParams(url.slice(index + 1));
+  return params.has("token") ? params.get("token") ?? "" : void 0;
+}
+function isAuthenticated(context, request) {
+  const cookieValue = readCookieValue(request.headers.cookie, context.cookieName);
+  return cookieValue !== void 0 && tokensMatch(cookieValue, context.token);
+}
+function finishConstant(context, response, method, path, status, body) {
+  sendConstantResponse(response, status, body);
+  context.log(formatRequestLog({ method, path, status }));
+}
+function sendRedirectToRoot(context, response, method, path) {
+  applyNoStore(response);
+  response.statusCode = 303;
+  response.setHeader("Location", "/");
+  response.end();
+  context.log(formatRequestLog({ method, path, status: 303 }));
+}
+function handleBootstrap(context, response, method, path, candidate) {
+  if (!tokensMatch(candidate, context.token)) {
+    finishConstant(context, response, method, path, 401, UNAUTHORIZED_BODY);
+    return;
+  }
+  response.setHeader("Set-Cookie", buildSetCookieHeader(context.cookieName, context.token));
+  sendRedirectToRoot(context, response, method, path);
+}
+async function serveStatic(context, response, method, path) {
+  const asset = await readAsset(context.assetsRootPath, path) ?? await readAsset(context.assetsRootPath, "/index.html");
+  if (asset === void 0) {
+    finishConstant(context, response, method, path, 404, NOT_FOUND_BODY);
+    return;
+  }
+  const contentType = contentTypeFor(asset.path);
+  if (contentType.startsWith("text/html")) {
+    applyNoStore(response);
+  }
+  response.statusCode = 200;
+  response.setHeader("Content-Type", contentType);
+  response.end(asset.body);
+  context.log(formatRequestLog({ method, path, status: 200 }));
+}
+function handleEvents(context, response, method, path) {
+  applyNoStore(response);
+  response.writeHead(200, { "Content-Type": "text/event-stream; charset=utf-8" });
+  response.write(": connected\n\n");
+  context.sseHub.register(response);
+  context.log(formatRequestLog({ method, path, status: 200 }));
+}
+async function handleGet(context, request, response, method, path) {
+  const bootstrapToken = path === "/" ? extractBootstrapToken(request.url ?? "/") : void 0;
+  if (bootstrapToken !== void 0) {
+    handleBootstrap(context, response, method, path, bootstrapToken);
+    return;
+  }
+  if (!isAuthenticated(context, request)) {
+    finishConstant(context, response, method, path, 401, UNAUTHORIZED_BODY);
+    return;
+  }
+  if (path === EVENTS_PATH) {
+    handleEvents(context, response, method, path);
+    return;
+  }
+  await serveStatic(context, response, method, path);
+}
+async function readRpcBody(context, request, response, method, path) {
+  try {
+    return await readBodyWithCap(request, BODY_CAP_BYTES);
+  } catch (error) {
+    if (error instanceof PayloadTooLargeError) {
+      finishConstant(context, response, method, path, 413, PAYLOAD_TOO_LARGE_BODY);
+      return void 0;
+    }
+    throw error;
+  }
+}
+async function handlePost(context, request, response, method, path) {
+  if (!isAllowedOrigin(request.headers.origin, context.port)) {
+    finishConstant(context, response, method, path, 403, FORBIDDEN_BODY);
+    return;
+  }
+  if (path !== "/rpc") {
+    finishConstant(context, response, method, path, 404, NOT_FOUND_BODY);
+    return;
+  }
+  if (!isAuthenticated(context, request)) {
+    finishConstant(context, response, method, path, 401, UNAUTHORIZED_BODY);
+    return;
+  }
+  if (!isJsonRequestContentType(request.headers["content-type"])) {
+    finishConstant(context, response, method, path, 415, UNSUPPORTED_MEDIA_TYPE_BODY);
+    return;
+  }
+  const body = await readRpcBody(context, request, response, method, path);
+  if (body === void 0) {
+    return;
+  }
+  const result = await handleRpcBody(body, context.rpcDeps);
+  applyNoStore(response);
+  response.statusCode = result.statusCode;
+  response.setHeader("Content-Type", "application/json; charset=utf-8");
+  response.end(result.body);
+  context.log(formatRequestLog({ method, path, status: result.statusCode }));
+}
+async function handleRequest(context, request, response) {
+  const method = request.method ?? "GET";
+  const path = pathWithoutQuery(request.url ?? "/");
+  applySecurityHeaders(response);
+  if (!isAllowedHost(request.headers.host, context.port)) {
+    finishConstant(context, response, method, path, 403, FORBIDDEN_BODY);
+    return;
+  }
+  if (method === "OPTIONS") {
+    finishConstant(context, response, method, path, 403, FORBIDDEN_BODY);
+    return;
+  }
+  if (method === "GET") {
+    await handleGet(context, request, response, method, path);
+    return;
+  }
+  if (method === "POST") {
+    await handlePost(context, request, response, method, path);
+    return;
+  }
+  finishConstant(context, response, method, path, 405, METHOD_NOT_ALLOWED_BODY);
+}
+
+// src/server/errors.ts
+var StudioServerStartError = class extends Error {
+  code;
+  port;
+  constructor(code, port, message) {
+    super(message);
+    this.name = "StudioServerStartError";
+    this.code = code;
+    this.port = port;
+  }
+};
+
+// src/server/resolve-bound-port.ts
+function resolveBoundAddress(address) {
+  if (address === null || typeof address === "string") {
+    throw new Error("verbatra studio server failed to bind a TCP address");
+  }
+  return address;
+}
+
+// src/shared/sse-events.ts
+var SSE_EVENT_REFRESH = "refresh";
+var SSE_EVENT_SHUTDOWN = "shutdown";
+
+// src/server/sse.ts
+var DEFAULT_HEARTBEAT_MS = 15e3;
+function tryWrite(response, event, data) {
+  const frame = redact(`event: ${event}
+data: ${JSON.stringify(data)}
+
+`);
+  try {
+    return response.write(frame);
+  } catch {
+    return false;
+  }
+}
+function tryWriteHeartbeat(response) {
+  try {
+    return response.write(`: heartbeat ${Date.now()}
+
+`);
+  } catch {
+    return false;
+  }
+}
+function tryEnd(response) {
+  try {
+    response.end();
+  } catch {
+  }
+}
+function createSseHub(options = {}) {
+  const clients = /* @__PURE__ */ new Set();
+  function deregister(response) {
+    clients.delete(response);
+  }
+  function register(response) {
+    clients.add(response);
+    response.once("close", () => deregister(response));
+    response.once("error", () => deregister(response));
+  }
+  function broadcastRefresh(event) {
+    for (const response of clients) {
+      if (!tryWrite(response, SSE_EVENT_REFRESH, event)) {
+        deregister(response);
+      }
+    }
+  }
+  function tickHeartbeat() {
+    for (const response of clients) {
+      if (!tryWriteHeartbeat(response)) {
+        deregister(response);
+      }
+    }
+  }
+  const heartbeatTimer = setInterval(
+    tickHeartbeat,
+    options.heartbeatIntervalMs ?? DEFAULT_HEARTBEAT_MS
+  );
+  heartbeatTimer.unref?.();
+  function closeAll() {
+    clearInterval(heartbeatTimer);
+    const shutdownEvent = { at: (/* @__PURE__ */ new Date()).toISOString() };
+    for (const response of clients) {
+      tryWrite(response, SSE_EVENT_SHUTDOWN, shutdownEvent);
+      tryEnd(response);
+    }
+    clients.clear();
+  }
+  return {
+    register,
+    broadcastRefresh,
+    closeAll,
+    get size() {
+      return clients.size;
+    }
+  };
+}
+var DEFAULT_DEBOUNCE_MS = 300;
+function watchedCategories(config, projectRoot) {
+  const source = localeFilePath(projectRoot, config.files.pattern, config.sourceLocale);
+  const targets = config.targetLocales.map(
+    (locale) => localeFilePath(projectRoot, config.files.pattern, locale)
+  );
+  const lock = resolve(projectRoot, LOCK_FILE_NAME);
+  const categories = [{ reason: "source", paths: [source] }];
+  if (targets.length > 0) {
+    categories.push({ reason: "targets", paths: targets });
+  }
+  categories.push({ reason: "lock", paths: [lock] });
+  return categories;
+}
+function createDebouncedTrigger(reason, debounceMs, emit) {
+  let timer;
+  return {
+    trigger() {
+      if (timer !== void 0) {
+        clearTimeout(timer);
+      }
+      timer = setTimeout(() => {
+        timer = void 0;
+        emit({ reason, at: (/* @__PURE__ */ new Date()).toISOString() });
+      }, debounceMs);
+    },
+    clear() {
+      if (timer !== void 0) {
+        clearTimeout(timer);
+        timer = void 0;
+      }
+    }
+  };
+}
+function createProjectWatcher(input, deps) {
+  const debounceMs = input.debounceMs ?? DEFAULT_DEBOUNCE_MS;
+  const listeners = /* @__PURE__ */ new Set();
+  function emit(event) {
+    for (const listener of listeners) {
+      listener(event);
+    }
+  }
+  const entries = watchedCategories(input.config, input.projectRoot).map((category) => {
+    const debounced = createDebouncedTrigger(category.reason, debounceMs, emit);
+    const watcher = deps.createWatcher(category.paths);
+    watcher.onChange(debounced.trigger);
+    return { debounced, watcher };
+  });
+  return {
+    onRefresh(listener) {
+      listeners.add(listener);
+    },
+    async close() {
+      for (const entry of entries) {
+        entry.debounced.clear();
+      }
+      await Promise.all(entries.map((entry) => entry.watcher.close()));
+    }
+  };
+}
+var defaultCreateStudioWatcher = (paths) => {
+  const fsWatcher = watch([...paths], { persistent: true, ignoreInitial: true });
+  return {
+    onChange(listener) {
+      fsWatcher.on("change", () => listener());
+      fsWatcher.on("add", () => listener());
+    },
+    close: () => fsWatcher.close()
+  };
+};
+
+// src/server/create-studio-server.ts
+var RAW_FORBIDDEN_RESPONSE = [
+  "HTTP/1.1 403 Forbidden",
+  "Content-Type: text/plain; charset=utf-8",
+  `Content-Length: ${Buffer.byteLength(FORBIDDEN_BODY)}`,
+  "Connection: close",
+  "",
+  FORBIDDEN_BODY
+].join("\r\n");
+function handleClientError(_error, socket) {
+  if (socket.writable) {
+    socket.end(RAW_FORBIDDEN_RESPONSE);
+  } else {
+    socket.destroy();
+  }
+}
+function defaultAssetsRoot() {
+  return new URL("./app/", import.meta.url);
+}
+function defaultOutput(line) {
+  console.log(line);
+}
+function buildRpcHandlerDeps(config, projectRoot, options) {
+  return {
+    config,
+    projectRoot,
+    ...options.fs !== void 0 ? { fs: options.fs } : {},
+    ...options.adapterRegistry !== void 0 ? { adapterRegistry: options.adapterRegistry } : {},
+    ...options.execFileImpl !== void 0 ? { execFileImpl: options.execFileImpl } : {},
+    ...options.createWatcher !== void 0 ? { createWatcher: options.createWatcher } : {},
+    ...options.heartbeatIntervalMs !== void 0 ? { heartbeatIntervalMs: options.heartbeatIntervalMs } : {}
+  };
+}
+function assertLoopbackAddress(address) {
+  if (address.address !== "127.0.0.1") {
+    throw new StudioServerStartError(
+      "BIND_FAILED",
+      address.port,
+      "verbatra studio server did not bind to 127.0.0.1"
+    );
+  }
+}
+function listen(server, port) {
+  return new Promise((resolve3, reject) => {
+    server.once("error", (error) => {
+      if (error.code === "EADDRINUSE") {
+        reject(new StudioServerStartError("PORT_IN_USE", port, `port ${port} is already in use`));
+        return;
+      }
+      reject(error);
+    });
+    server.listen(port, "127.0.0.1", () => {
+      try {
+        resolve3(resolveBoundAddress(server.address()));
+      } catch (error) {
+        reject(error);
+      }
+    });
+  });
+}
+function closeServer(server, sseHub, watcher) {
+  sseHub.closeAll();
+  const serverClosed = new Promise((resolve3, reject) => {
+    server.close((error) => error ? reject(error) : resolve3());
+    server.closeAllConnections();
+  });
+  return Promise.all([serverClosed, watcher.close()]).then(() => void 0);
+}
+async function startStudioServer(options) {
+  const assetsRootPath = fileURLToPath(options.assetsRoot ?? defaultAssetsRoot());
+  const output = options.output ?? defaultOutput;
+  const token = options.token ?? generateToken();
+  const config = await options.loader();
+  const projectRoot = options.cwd ?? process.cwd();
+  const watcher = createProjectWatcher(
+    { config: config.config, projectRoot },
+    { createWatcher: options.createWatcher ?? defaultCreateStudioWatcher }
+  );
+  const sseHub = createSseHub(
+    options.heartbeatIntervalMs !== void 0 ? { heartbeatIntervalMs: options.heartbeatIntervalMs } : {}
+  );
+  watcher.onRefresh((event) => sseHub.broadcastRefresh(event));
+  const server = createServer();
+  server.on("clientError", handleClientError);
+  const address = await listen(server, resolvePort(options.port));
+  assertLoopbackAddress(address);
+  const port = address.port;
+  const context = {
+    port,
+    token,
+    cookieName: cookieName(port),
+    assetsRootPath,
+    log: output,
+    rpcDeps: buildRpcHandlerDeps(config, projectRoot, options),
+    sseHub
+  };
+  server.on("request", (request, response) => {
+    handleRequest(context, request, response).catch(() => {
+      request.destroy();
+      response.destroy();
+    });
+  });
+  const url = `http://127.0.0.1:${port}/`;
+  output(buildBanner(url, token));
+  return {
+    url,
+    port,
+    close: () => closeServer(server, sseHub, watcher)
+  };
+}
+
+export { DEFAULT_STUDIO_PORT, StudioServerStartError, startStudioServer };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map