farming-code 2.2.30 → 2.2.32

package/backend/{terminal-screen-worker-thread.js → terminal-screen-worker-thread.cjs}

@@ -1,160 +1,162 @@
-const { parentPort, workerData } = require('worker_threads');
-const TerminalScreenState = require('./terminal-screen-state');
-
+// Generated by scripts/build-backend-runtime.ts. Do not edit.
+"use strict";
+var import_worker_threads = require("worker_threads");
+var import_terminal_screen_state = require("./terminal-screen-state.cjs");
 const PREVIEW_FLUSH_INTERVAL_MS = 50;
-
-const screenState = new TerminalScreenState(workerData || {});
-let runtimeEpoch = typeof workerData.runtimeEpoch === 'string' ? workerData.runtimeEpoch : '';
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+const workerPort = import_worker_threads.parentPort;
+const initialWorkerData = import_worker_threads.workerData && typeof import_worker_threads.workerData === "object" ? import_worker_threads.workerData : {};
+const screenState = new import_terminal_screen_state.TerminalScreenState(initialWorkerData);
+let runtimeEpoch = typeof initialWorkerData.runtimeEpoch === "string" ? initialWorkerData.runtimeEpoch : "";
 let appliedOutputSeq = 0;
 let appliedStateRevision = 0;
-let lastPreviewText = '';
-let lastTitle = '';
-let lastSnapshotFingerprint = '';
+let lastPreviewText = "";
+let lastTitle = "";
+let lastSnapshotFingerprint = "";
 let messageQueue = Promise.resolve();
 let previewFlushTimer = null;
-
 function postPreview(state) {
-  const previewText = state.previewText || '';
-  const title = state.title || '';
+  const previewText = state.previewText || "";
+  const title = state.title || "";
   const previewSnapshot = state.previewSnapshot || null;
-  const snapshotFingerprint = previewSnapshot ? JSON.stringify(previewSnapshot) : '';
-
+  const snapshotFingerprint = previewSnapshot ? JSON.stringify(previewSnapshot) : "";
   if (previewText === lastPreviewText && title === lastTitle && snapshotFingerprint === lastSnapshotFingerprint) {
     return;
   }
-
   lastPreviewText = previewText;
   lastTitle = title;
   lastSnapshotFingerprint = snapshotFingerprint;
-  parentPort.postMessage({
-    type: 'preview',
+  workerPort?.postMessage({
+    type: "preview",
     previewText,
     title,
     cols: state.cols || 0,
     rows: state.rows || 0,
-    previewSnapshot,
+    previewSnapshot
   });
 }
-
 function withOutputSeq(state) {
   return {
     ...state,
     runtimeEpoch,
     outputSeq: appliedOutputSeq,
-    stateRevision: appliedStateRevision,
+    stateRevision: appliedStateRevision
   };
 }
-
 function currentState(options = {}) {
   const state = screenState.getState({
     includeRenderOutput: options.includeRenderOutput,
-    refreshPreview: options.refreshPreview,
+    refreshPreview: options.refreshPreview
   });
   if (options.emitPreview) {
     postPreview(state);
   }
   return withOutputSeq(state);
 }
-
 function schedulePreview() {
   if (previewFlushTimer) return;
   previewFlushTimer = setTimeout(() => {
     previewFlushTimer = null;
     postPreview(currentState({
       includeRenderOutput: false,
-      refreshPreview: true,
+      refreshPreview: true
     }));
   }, PREVIEW_FLUSH_INTERVAL_MS);
-  if (typeof previewFlushTimer.unref === 'function') previewFlushTimer.unref();
+  if (typeof previewFlushTimer.unref === "function") previewFlushTimer.unref();
 }
-
 function assertNextRevision(stateRevision, transition) {
   if (!Number.isFinite(stateRevision) || stateRevision !== appliedStateRevision + 1) {
     throw new Error(
-      `Terminal screen ${transition} revision gap: expected ${appliedStateRevision + 1}, received ${stateRevision}`,
+      `Terminal screen ${transition} revision gap: expected ${appliedStateRevision + 1}, received ${stateRevision}`
     );
   }
 }
-
+function assertFiniteDimension(value, name) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new Error(`Terminal screen ${name} must be finite`);
+  }
+}
 async function appendEntries(rawEntries) {
   const entries = Array.isArray(rawEntries) ? rawEntries : [];
   if (entries.length === 0) return;
-
   let expectedRevision = appliedStateRevision + 1;
   let nextOutputSeq = appliedOutputSeq;
-  let data = '';
-  for (const entry of entries) {
-    const stateRevision = Number(entry && entry.stateRevision);
+  let data = "";
+  for (const value of entries) {
+    const entry = value && typeof value === "object" ? value : {};
+    const stateRevision = Number(entry.stateRevision);
     if (!Number.isFinite(stateRevision) || stateRevision !== expectedRevision) {
       throw new Error(
-        `Terminal screen append revision gap: expected ${expectedRevision}, received ${entry && entry.stateRevision}`,
+        `Terminal screen append revision gap: expected ${expectedRevision}, received ${entry.stateRevision}`
       );
     }
-    const text = String((entry && entry.data) || '');
+    const text = String(entry.data || "");
     if (!text) {
       throw new Error(`Terminal screen append revision ${stateRevision} has no data`);
     }
-    const outputSeq = Number(entry && entry.outputSeq);
+    const outputSeq = Number(entry.outputSeq);
     if (!Number.isFinite(outputSeq) || outputSeq !== nextOutputSeq + 1) {
       throw new Error(
-        `Terminal screen output sequence gap: expected ${nextOutputSeq + 1}, received ${entry && entry.outputSeq}`,
+        `Terminal screen output sequence gap: expected ${nextOutputSeq + 1}, received ${entry.outputSeq}`
       );
     }
     data += text;
     nextOutputSeq = outputSeq;
     expectedRevision += 1;
   }
-
   const state = await screenState.write(data);
   appliedStateRevision = expectedRevision - 1;
   appliedOutputSeq = nextOutputSeq;
   schedulePreview();
   return state;
 }
-
 async function handleRequest(message) {
   switch (message.type) {
-    case 'append':
+    case "append":
       await appendEntries(message.entries);
       return currentState({
         includeRenderOutput: false,
-        refreshPreview: false,
+        refreshPreview: false
       });
-    case 'set-runtime-epoch':
-      runtimeEpoch = typeof message.runtimeEpoch === 'string' ? message.runtimeEpoch : '';
+    case "set-runtime-epoch":
+      runtimeEpoch = typeof message.runtimeEpoch === "string" ? message.runtimeEpoch : "";
       appliedOutputSeq = 0;
       appliedStateRevision = 0;
-      if (Number.isFinite(message.cols) && Number.isFinite(message.rows)) {
+      if (typeof message.cols === "number" && Number.isFinite(message.cols) && typeof message.rows === "number" && Number.isFinite(message.rows)) {
         screenState.resize(message.cols, message.rows);
       }
       return currentState({ includeRenderOutput: false });
-    case 'resize': {
-      assertNextRevision(message.stateRevision, 'resize');
+    case "resize": {
+      assertNextRevision(message.stateRevision, "resize");
+      assertFiniteDimension(message.cols, "columns");
+      assertFiniteDimension(message.rows, "rows");
       screenState.resize(message.cols, message.rows);
       appliedStateRevision = message.stateRevision;
       const state = screenState.getState({ includeRenderOutput: true });
       postPreview(state);
       return withOutputSeq(state);
     }
-    case 'clear': {
-      assertNextRevision(message.stateRevision, 'clear');
+    case "clear": {
+      assertNextRevision(message.stateRevision, "clear");
       const state = await screenState.clearBuffer();
       const outputSeq = Number(message.outputSeq);
       if (!Number.isFinite(outputSeq) || outputSeq !== appliedOutputSeq) {
         throw new Error(
-          `Terminal screen clear output sequence mismatch: expected ${appliedOutputSeq}, received ${message.outputSeq}`,
+          `Terminal screen clear output sequence mismatch: expected ${appliedOutputSeq}, received ${message.outputSeq}`
         );
       }
       appliedStateRevision = message.stateRevision;
       postPreview(state);
       return withOutputSeq(state);
     }
-    case 'get-state':
+    case "get-state":
       return currentState({
         includeRenderOutput: message.includeRenderOutput !== false,
-        emitPreview: false,
+        emitPreview: false
       });
-    case 'dispose':
+    case "dispose":
       if (previewFlushTimer) {
         clearTimeout(previewFlushTimer);
         previewFlushTimer = null;
@@ -165,37 +167,34 @@ async function handleRequest(message) {
       throw new Error(`Unknown worker message type: ${message.type}`);
   }
 }
-
 async function processMessage(message) {
   try {
     const payload = await handleRequest(message);
     if (message.requestId) {
-      parentPort.postMessage({
-        type: 'response',
+      workerPort?.postMessage({
+        type: "response",
         requestId: message.requestId,
-        payload,
+        payload
       });
     }
   } catch (error) {
     if (message.requestId) {
-      parentPort.postMessage({
-        type: 'response',
+      workerPort?.postMessage({
+        type: "response",
         requestId: message.requestId,
-        error: error.message,
+        error: errorMessage(error)
       });
       return;
     }
-
-    parentPort.postMessage({
-      type: 'error',
-      message: error.message,
+    workerPort?.postMessage({
+      type: "error",
+      message: errorMessage(error)
     });
   }
 }
-
-parentPort.on('message', (message) => {
+workerPort?.on("message", (message) => {
   messageQueue = messageQueue.then(
     () => processMessage(message),
-    () => processMessage(message),
+    () => processMessage(message)
   );
 });

package/backend/terminal-screen-worker.cjs

@@ -0,0 +1,352 @@
+// Generated by scripts/build-backend-runtime.ts. Do not edit.
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var terminal_screen_worker_exports = {};
+__export(terminal_screen_worker_exports, {
+  DEFAULT_REQUEST_TIMEOUT_MS: () => DEFAULT_REQUEST_TIMEOUT_MS,
+  DEFAULT_STATE_REQUEST_HARD_TIMEOUT_MS: () => DEFAULT_STATE_REQUEST_HARD_TIMEOUT_MS,
+  TerminalScreenWorker: () => TerminalScreenWorker,
+  resolveWorkerFile: () => resolveWorkerFile
+});
+module.exports = __toCommonJS(terminal_screen_worker_exports);
+var path = __toESM(require("path"));
+var fs = __toESM(require("fs"));
+var import_events = require("events");
+var import_worker_threads = require("worker_threads");
+const APPEND_FLUSH_INTERVAL_MS = 16;
+const MAX_PENDING_APPEND_BYTES = 128 * 1024;
+const DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
+const DEFAULT_STATE_REQUEST_HARD_TIMEOUT_MS = 5e3;
+const PACKAGED_WORKER_FILE = "terminal-screen-worker-thread.pkg.js";
+const SOURCE_WORKER_FILE = "terminal-screen-worker-thread.cjs";
+function errorCode(error) {
+  return error && typeof error === "object" && "code" in error ? String(error.code) : "";
+}
+function byteLength(value) {
+  return Buffer.byteLength(String(value || ""), "utf8");
+}
+function finiteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function resolveWorkerFile() {
+  const wantsPackagedWorker = process.pkg || process.env.FARMING_PACKAGED_RUNTIME === "1";
+  if (!wantsPackagedWorker) return SOURCE_WORKER_FILE;
+  const packagedWorkerPath = path.join(__dirname, PACKAGED_WORKER_FILE);
+  return fs.existsSync(packagedWorkerPath) ? PACKAGED_WORKER_FILE : SOURCE_WORKER_FILE;
+}
+class TerminalScreenWorker extends import_events.EventEmitter {
+  static DEFAULT_REQUEST_TIMEOUT_MS = DEFAULT_REQUEST_TIMEOUT_MS;
+  static DEFAULT_STATE_REQUEST_HARD_TIMEOUT_MS = DEFAULT_STATE_REQUEST_HARD_TIMEOUT_MS;
+  static resolveWorkerFile = resolveWorkerFile;
+  worker;
+  pendingRequests = /* @__PURE__ */ new Map();
+  pendingAppendEntries = [];
+  pendingAppendWaiters = [];
+  pendingAppendBytes = 0;
+  appendFlushTimer = null;
+  stateRequestInFlight = null;
+  failed = false;
+  disposed = false;
+  nextRequestId = 1;
+  requestTimeoutMs;
+  stateRequestHardTimeoutMs;
+  constructor(options = {}) {
+    super();
+    const requestTimeoutMs = finiteNumber(options.requestTimeoutMs);
+    this.requestTimeoutMs = requestTimeoutMs !== null ? Math.max(1, Math.floor(requestTimeoutMs)) : DEFAULT_REQUEST_TIMEOUT_MS;
+    const stateRequestHardTimeoutMs = finiteNumber(options.stateRequestHardTimeoutMs);
+    this.stateRequestHardTimeoutMs = stateRequestHardTimeoutMs !== null ? Math.max(1, Math.floor(stateRequestHardTimeoutMs)) : Math.min(this.requestTimeoutMs, DEFAULT_STATE_REQUEST_HARD_TIMEOUT_MS);
+    const workerFile = resolveWorkerFile();
+    const WorkerClass = options.WorkerClass || import_worker_threads.Worker;
+    const workerData = { ...options };
+    delete workerData.WorkerClass;
+    delete workerData.requestTimeoutMs;
+    delete workerData.stateRequestHardTimeoutMs;
+    this.worker = new WorkerClass(path.join(__dirname, workerFile), {
+      workerData
+    });
+    this.worker.on("message", (value) => {
+      const message = value && typeof value === "object" ? value : null;
+      if (!message || typeof message !== "object") {
+        return;
+      }
+      if (message.type === "preview") {
+        this.emit("preview", {
+          previewText: message.previewText || "",
+          title: message.title || "",
+          cols: message.cols || 0,
+          rows: message.rows || 0,
+          previewSnapshot: message.previewSnapshot || null
+        });
+        return;
+      }
+      if (message.type === "response" && typeof message.requestId === "number") {
+        const pending = this.pendingRequests.get(message.requestId);
+        if (!pending) return;
+        this.pendingRequests.delete(message.requestId);
+        clearTimeout(pending.timer);
+        if (message.error) {
+          pending.reject(new Error(String(message.error)));
+          return;
+        }
+        pending.resolve(message.payload);
+        return;
+      }
+      if (message.type === "error") {
+        this.emit("error", new Error(String(message.message || "Unknown worker error")));
+      }
+    });
+    this.worker.on("error", (error) => {
+      this.handleWorkerFailure(error);
+    });
+    this.worker.on("exit", (code) => {
+      if (this.disposed) {
+        return;
+      }
+      this.handleWorkerFailure(new Error(`Terminal screen worker exited unexpectedly with code ${code}`));
+    });
+  }
+  handleWorkerFailure(error) {
+    if (this.disposed) return;
+    const failure = error instanceof Error ? error : new Error(String(error));
+    const shouldEmit = !this.failed;
+    this.failed = true;
+    if (this.appendFlushTimer) {
+      clearTimeout(this.appendFlushTimer);
+      this.appendFlushTimer = null;
+    }
+    this.pendingAppendEntries = [];
+    this.pendingAppendBytes = 0;
+    this.pendingAppendWaiters.splice(0).forEach(({ reject }) => reject(failure));
+    this.pendingRequests.forEach(({ reject, timer }) => {
+      clearTimeout(timer);
+      reject(failure);
+    });
+    this.pendingRequests.clear();
+    if (shouldEmit && this.listenerCount("error") > 0) {
+      this.emit("error", failure);
+    }
+  }
+  handlePostMessageFailure(error) {
+    this.handleWorkerFailure(error);
+  }
+  postWorkerMessage(message, options = {}) {
+    try {
+      this.worker.postMessage(message);
+      return true;
+    } catch (error) {
+      if (options.throwOnError) throw error;
+      this.handlePostMessageFailure(error);
+      return false;
+    }
+  }
+  flushAppend() {
+    if (this.appendFlushTimer) {
+      clearTimeout(this.appendFlushTimer);
+      this.appendFlushTimer = null;
+    }
+    if (this.disposed || this.failed || this.pendingAppendEntries.length === 0) {
+      this.pendingAppendEntries = [];
+      this.pendingAppendBytes = 0;
+      return;
+    }
+    const entries = this.pendingAppendEntries;
+    const waiters = this.pendingAppendWaiters;
+    this.pendingAppendEntries = [];
+    this.pendingAppendBytes = 0;
+    this.pendingAppendWaiters = [];
+    this.request("append", { entries }, { flushAppend: false }).then(
+      (state) => waiters.forEach(({ resolve }) => resolve(state)),
+      (error) => waiters.forEach(({ reject }) => reject(error))
+    );
+  }
+  request(type, payload = {}, options = {}) {
+    if (this.disposed) {
+      return Promise.reject(new Error("Terminal screen worker is disposed"));
+    }
+    if (this.failed) {
+      return Promise.reject(new Error("Terminal screen worker is not available"));
+    }
+    if (options.flushAppend !== false) {
+      this.flushAppend();
+    }
+    if (this.failed) {
+      return Promise.reject(new Error("Terminal screen worker is not available"));
+    }
+    const requestId = this.nextRequestId;
+    this.nextRequestId += 1;
+    return new Promise((resolve, reject) => {
+      const requestedTimeoutMs = finiteNumber(options.timeoutMs);
+      const requestTimeoutMs = requestedTimeoutMs !== null ? Math.max(1, Math.floor(requestedTimeoutMs)) : this.requestTimeoutMs;
+      const timer = setTimeout(() => {
+        this.pendingRequests.delete(requestId);
+        const error = Object.assign(
+          new Error(`Terminal screen worker request timed out: ${type}`),
+          { code: "ETIMEDOUT" }
+        );
+        reject(error);
+      }, requestTimeoutMs);
+      if (typeof timer.unref === "function") timer.unref();
+      this.pendingRequests.set(requestId, { resolve, reject, timer });
+      try {
+        this.postWorkerMessage({
+          requestId,
+          type,
+          ...payload
+        }, { throwOnError: true });
+      } catch (error) {
+        this.pendingRequests.delete(requestId);
+        clearTimeout(timer);
+        this.handlePostMessageFailure(error);
+        reject(error);
+      }
+    });
+  }
+  append(data, stateRevision, outputSeq = null) {
+    if (this.disposed || this.failed) {
+      return Promise.reject(new Error("Terminal screen worker is not available"));
+    }
+    const text = String(data || "");
+    if (!text) return;
+    if (!Number.isFinite(stateRevision)) {
+      this.handlePostMessageFailure(new Error("Terminal screen append requires a finite state revision"));
+      return Promise.reject(new Error("Terminal screen append requires a finite state revision"));
+    }
+    if (this.pendingAppendEntries.length > 0 && this.pendingAppendBytes + byteLength(text) > MAX_PENDING_APPEND_BYTES) {
+      this.flushAppend();
+    }
+    return new Promise((resolve, reject) => {
+      this.pendingAppendEntries.push({ data: text, stateRevision, outputSeq });
+      this.pendingAppendBytes += byteLength(text);
+      this.pendingAppendWaiters.push({ resolve, reject });
+      if (byteLength(text) > MAX_PENDING_APPEND_BYTES) {
+        this.flushAppend();
+        return;
+      }
+      if (this.appendFlushTimer) return;
+      this.appendFlushTimer = setTimeout(() => {
+        this.flushAppend();
+      }, APPEND_FLUSH_INTERVAL_MS);
+    });
+  }
+  resize(cols, rows, stateRevision) {
+    return this.request(
+      "resize",
+      { cols, rows, stateRevision }
+    );
+  }
+  setRuntimeEpoch(runtimeEpoch, cols, rows) {
+    return this.request("set-runtime-epoch", { runtimeEpoch, cols, rows });
+  }
+  clear(stateRevision, outputSeq = null) {
+    return this.request("clear", { stateRevision, outputSeq });
+  }
+  getState(options = {}) {
+    if (!this.stateRequestInFlight) {
+      const request = this.request("get-state", {
+        // A full checkpoint can satisfy callers that only need metadata too,
+        // while the reverse would make coalescing unsafe.
+        includeRenderOutput: true
+      }, {
+        // Caller deadlines are deliberately softer than this shared deadline.
+        // A timed-out caller may stop waiting, but the single-flight itself
+        // must never poison every later checkpoint for the generic 30s worker
+        // request timeout. Crossing this hard deadline means the authoritative
+        // reducer can no longer prove progress, so fail it closed.
+        timeoutMs: this.stateRequestHardTimeoutMs
+      });
+      const sharedRequest2 = request.catch((error) => {
+        if (errorCode(error) === "ETIMEDOUT") {
+          this.handleWorkerFailure(error);
+        }
+        throw error;
+      }).finally(() => {
+        if (this.stateRequestInFlight === sharedRequest2) {
+          this.stateRequestInFlight = null;
+        }
+      });
+      this.stateRequestInFlight = sharedRequest2;
+    }
+    const sharedRequest = this.stateRequestInFlight;
+    const timeoutMs = typeof options.timeoutMs === "number" && Number.isFinite(options.timeoutMs) ? Math.max(1, Math.floor(options.timeoutMs)) : null;
+    if (timeoutMs === null) return sharedRequest;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        const error = Object.assign(
+          new Error("Terminal screen worker request timed out: get-state"),
+          { code: "ETIMEDOUT" }
+        );
+        reject(error);
+      }, timeoutMs);
+      if (typeof timer.unref === "function") timer.unref();
+      sharedRequest.then(
+        (state) => {
+          clearTimeout(timer);
+          resolve(state);
+        },
+        (error) => {
+          clearTimeout(timer);
+          reject(error);
+        }
+      );
+    });
+  }
+  async dispose() {
+    if (this.disposed) {
+      return;
+    }
+    try {
+      await this.request("dispose");
+    } catch {
+    }
+    if (this.appendFlushTimer) {
+      clearTimeout(this.appendFlushTimer);
+      this.appendFlushTimer = null;
+    }
+    this.pendingAppendEntries = [];
+    this.pendingAppendBytes = 0;
+    this.pendingAppendWaiters.splice(0).forEach(({ reject }) => {
+      reject(new Error("Terminal screen worker is disposed"));
+    });
+    this.disposed = true;
+    this.pendingRequests.forEach(({ reject, timer }) => {
+      clearTimeout(timer);
+      reject(new Error("Terminal screen worker disposed"));
+    });
+    this.pendingRequests.clear();
+    await this.worker.terminate();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_REQUEST_TIMEOUT_MS,
+  DEFAULT_STATE_REQUEST_HARD_TIMEOUT_MS,
+  TerminalScreenWorker,
+  resolveWorkerFile
+});