@rsconcept/rstool 0.1.0 → 0.2.0

package/dist/wrapper/stdio-wrapper.js

@@ -1,679 +1,181 @@
 #!/usr/bin/env node
-
-// src/wrapper/stdio-wrapper.ts
-import readline from "readline";
-
-// src/mappers/model-adapter.ts
-import { Graph } from "@rsconcept/domain/graph/graph";
-import { extractGlobals } from "@rsconcept/domain/rslang/api";
-import { RSLangAnalyzer } from "@rsconcept/domain/rslang";
-import { isBaseSet } from "@rsconcept/domain/library/rsform-api";
-import { CstType } from "@rsconcept/domain/library/rsform";
-import { RSEngine } from "@rsconcept/domain/library/rsengine";
-import { EvalStatus } from "@rsconcept/domain/library/rsmodel";
-import {
-  isInferrable,
-  isInterpretable,
-  toBasicBinding,
-  validateBasicBindingData,
-  validateValueData
-} from "@rsconcept/domain/library/rsmodel-api";
-
-// src/mappers/types.ts
-function toPublicError(error) {
-  return {
-    code: error.code,
-    from: error.from,
-    to: error.to,
-    params: error.params
-  };
-}
-function toPublicAnalysis(analysis) {
-  return {
-    success: analysis.success,
-    type: analysis.type,
-    valueClass: analysis.valueClass,
-    diagnostics: analysis.errors.map(toPublicError)
-  };
-}
-
-// src/mappers/model-adapter.ts
-var SESSION_MODEL_ID = 0;
-var ModelAdapter = class {
-  async setConstituentaValue(session, input2) {
-    this.validateSetInput(session, input2);
-    const engine = this.createEngine(session);
-    const cst = session.items.find((item) => item.id === input2.target);
-    const frontendType = cst.cstType;
-    if (isBaseSet(frontendType)) {
-      const binding = toBasicBinding(input2.value);
-      await engine.setBasicValue(input2.target, binding);
-    } else {
-      await engine.setStructureValue(input2.target, input2.value);
-    }
-    session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    return structuredClone(session.model);
-  }
-  async setConstituentaValues(session, input2) {
-    for (const item of input2.items) {
-      await this.setConstituentaValue(session, item);
-    }
-    return structuredClone(session.model);
-  }
-  async clearConstituentaValues(session, ids) {
-    const engine = this.createEngine(session);
-    for (const id of ids) {
-      await engine.resetValue(id);
-      session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    }
-    return structuredClone(session.model);
-  }
-  evaluateExpression(session, expression, cstType) {
-    const engine = this.createEngine(session);
-    const result = engine.evaluateExpression(expression, cstType);
-    const status = result.value === null ? result.errors.length > 0 ? EvalStatus.EVAL_FAIL : EvalStatus.EMPTY : EvalStatus.HAS_DATA;
-    return toPublicEvaluationResult(result.value, result.errors, result.iterations, result.cacheHits, status);
-  }
-  evaluateConstituenta(session, constituentId) {
-    const cst = session.items.find((item) => item.id === constituentId);
-    if (!cst) {
-      throw new Error(`Unknown constituent: ${constituentId}`);
-    }
-    const engine = this.createEngine(session);
-    const result = engine.calculateCst(constituentId);
-    const status = engine.getCstStatus(constituentId);
-    return toPublicEvaluationResult(result.value, result.errors, result.iterations, result.cacheHits, status);
-  }
-  recalculateModel(session) {
-    const engine = this.createEngine(session);
-    engine.recalculateAll();
-    const items = session.items.map((item) => ({
-      id: item.id,
-      alias: item.alias,
-      value: engine.getCstValue(item.id),
-      status: engine.getCstStatus(item.id)
-    }));
-    return { items };
-  }
-  createEngine(session) {
-    const schema = buildRSFormFromSession(session);
-    const model = buildRSModelFromSession(session);
-    const engine = new RSEngine(SESSION_MODEL_ID, createInMemoryServices(session));
-    engine.loadData(schema, model);
-    return engine;
-  }
-  validateSetInput(session, input2) {
-    const cst = session.items.find((item) => item.id === input2.target);
-    if (!cst) {
-      throw new Error(`Unknown constituent: ${input2.target}`);
-    }
-    const frontendType = cst.cstType;
-    if (!isInterpretable(frontendType)) {
-      throw new Error(`Constituent ${cst.alias} is not interpretable`);
-    }
-    if (isInferrable(frontendType)) {
-      throw new Error(`Constituent ${cst.alias} is inferrable and cannot be set directly`);
-    }
-    if (isBaseSet(frontendType)) {
-      if (!validateBasicBindingData(input2.value)) {
-        throw new Error(`Invalid basic binding for ${cst.alias}`);
-      }
-      return;
-    }
-    if (!validateValueData(input2.value)) {
-      throw new Error(`Invalid structured value for ${cst.alias}`);
-    }
-  }
-};
-function createInMemoryServices(session) {
-  return {
-    setCstValue: async ({ data }) => {
-      for (const item of data) {
-        const entry = {
-          id: item.target,
-          type: item.type,
-          value: item.data
-        };
-        const index = session.model.items.findIndex((existing) => existing.id === item.target);
-        if (index === -1) {
-          session.model.items.push(entry);
-        } else {
-          session.model.items[index] = entry;
-        }
-      }
-    },
-    clearValues: async ({ data }) => {
-      const ids = new Set(data.items);
-      session.model.items = session.model.items.filter((item) => !ids.has(item.id));
-    }
-  };
-}
-function buildRSFormFromSession(session) {
-  const graph = new Graph();
-  const cstByAlias = /* @__PURE__ */ new Map();
-  const cstByID = /* @__PURE__ */ new Map();
-  const analyzer = new RSLangAnalyzer();
-  const items = session.items.map((item) => {
-    const cst = toFrontendConstituenta(item);
-    cstByAlias.set(cst.alias, cst);
-    cstByID.set(cst.id, cst);
-    graph.addNode(cst.id);
-    if (item.cstType === CstType.BASE) {
-      analyzer.addBase(cst.alias);
-    }
-    if (cst.effectiveType) {
-      analyzer.setGlobal(cst.alias, cst.effectiveType, cst.analysis.valueClass);
-    }
-    return cst;
-  });
-  for (const cst of items) {
-    for (const alias of extractGlobals(cst.definition_formal)) {
-      const source = cstByAlias.get(alias);
-      if (source) {
-        graph.addEdge(source.id, cst.id);
-      }
-    }
-  }
-  return {
-    id: 0,
-    items,
-    cstByAlias,
-    cstByID,
-    graph,
-    analyzer,
-    inheritance: [],
-    attribution: [],
-    attribution_graph: graph.clone(),
-    oss: [],
-    models: [],
-    editors: [],
-    versions: [],
-    is_produced: false,
-    is_attributive: false,
-    version: "latest"
-  };
-}
-function buildRSModelFromSession(session) {
-  return {
-    id: SESSION_MODEL_ID,
-    schema: 0,
-    editors: [],
-    items: session.model.items.map((item) => ({
-      id: item.id,
-      type: item.type,
-      value: item.value
-    }))
-  };
-}
-function toFrontendConstituenta(item) {
-  const effectiveType = item.analysis.type ?? null;
-  return {
-    id: item.id,
-    alias: item.alias,
-    cst_type: item.cstType,
-    definition_formal: item.definitionFormal,
-    definition_raw: item.definitionFormal,
-    definition_resolved: item.definitionFormal,
-    term_raw: item.term,
-    term_resolved: item.term,
-    term_forms: [],
-    convention: item.convention,
-    typification_manual: "",
-    value_is_property: false,
-    crucial: false,
-    attributes: [],
-    homonyms: [],
-    formalDuplicates: [],
-    analysis: {
-      success: item.analysis.success,
-      type: effectiveType,
-      valueClass: item.analysis.valueClass
-    },
-    effectiveType,
-    is_type_mismatch: false,
-    schema: 0,
-    cst_class: "derived",
-    status: item.analysis.success ? "verified" : "incorrect",
-    is_template: false,
-    is_simple_expression: true,
-    parent_schema_index: 0,
-    parent_schema: null,
-    is_inherited: false,
-    has_inherited_children: false,
-    spawn: [],
-    spawn_alias: []
-  };
-}
-function toPublicEvaluationResult(value, errors, iterations, cacheHits, status) {
-  const diagnostics = errors.map(toPublicError);
-  return {
-    success: diagnostics.length === 0 && value !== null,
-    value,
-    status,
-    iterations,
-    cacheHits,
-    diagnostics
-  };
-}
-
-// src/mappers/schema-adapter.ts
-import { RSLangAnalyzer as RSLangAnalyzer2 } from "@rsconcept/domain/rslang";
-import { getAnalysisFor } from "@rsconcept/domain/library/rsform-api";
-import { CstType as CstType2 } from "@rsconcept/domain/library/rsform";
-var SchemaAdapter = class {
-  analyzeAgainstSession(session, draft) {
-    const analyzer = this.buildAnalyzer(session);
-    const schema = this.toPseudoRSFormState(session, analyzer);
-    const analysis = getAnalysisFor(draft.definitionFormal, draft.cstType, schema, draft.alias);
-    const result = toPublicAnalysis({
-      success: analysis.success,
-      type: analysis.type,
-      valueClass: analysis.valueClass,
-      errors: analysis.errors
-    });
-    return {
-      result,
-      diagnostics: analysis.errors.map((error) => ({
-        sessionId: session.sessionId,
-        constituentId: draft.id,
-        expression: draft.definitionFormal,
-        error: toPublicError(error)
-      }))
-    };
-  }
-  mergeStateWithDraft(session, draft, analysis) {
-    const state = {
-      ...draft,
-      term: draft.term ?? "",
-      definitionText: draft.definitionText ?? "",
-      convention: draft.convention ?? "",
-      analysis
-    };
-    const index = session.items.findIndex((item) => item.id === draft.id);
-    if (index === -1) {
-      session.items.push(state);
-    } else {
-      session.items[index] = state;
-    }
-    session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    return state;
-  }
-  toPseudoRSFormState(session, analyzer) {
-    const cstByAlias = new Map(session.items.map((item) => [item.alias, item]));
-    return {
-      items: session.items,
-      cstByAlias,
-      analyzer
-    };
-  }
-  buildAnalyzer(session) {
-    const analyzer = new RSLangAnalyzer2();
-    for (const item of session.items) {
-      if (item.cstType === CstType2.BASE) {
-        analyzer.addBase(item.alias);
-      }
-      analyzer.setGlobal(
-        item.alias,
-        item.analysis.type,
-        item.analysis.valueClass
-      );
-    }
-    return analyzer;
-  }
-};
-
-// src/session/session-store.ts
-import { randomUUID } from "crypto";
-var SessionStore = class {
-  sessions = /* @__PURE__ */ new Map();
-  create(initial, contractVersion) {
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const sessionId = initial?.sessionId ?? randomUUID();
-    const state = {
-      sessionId,
-      createdAt: initial?.createdAt ?? now,
-      updatedAt: now,
-      revisions: initial?.revisions ?? [],
-      items: initial?.items ?? [],
-      model: initial?.model ?? { items: [] }
-    };
-    this.sessions.set(sessionId, {
-      state,
-      diagnostics: []
-    });
-    return {
-      sessionId,
-      contractVersion: contractVersion ?? "1.0.0"
-    };
-  }
-  get(sessionId) {
-    const found = this.sessions.get(sessionId);
-    if (!found) {
-      throw new Error(`Unknown session: ${sessionId}`);
-    }
-    return found;
-  }
-  replaceState(sessionId, nextState) {
-    const found = this.get(sessionId);
-    found.state = {
-      ...nextState,
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-  }
-  addRevision(sessionId, message) {
-    const found = this.get(sessionId);
-    const revision = {
-      revisionId: randomUUID(),
-      at: (/* @__PURE__ */ new Date()).toISOString(),
-      message
-    };
-    found.state.revisions.push(revision);
-    found.state.updatedAt = revision.at;
-    return revision;
-  }
-  appendDiagnostics(sessionId, records) {
-    const found = this.get(sessionId);
-    found.diagnostics.push(...records);
-    found.state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  }
-  listDiagnostics(sessionId, filters) {
-    const found = this.get(sessionId);
-    if (!filters?.constituentId) {
-      return [...found.diagnostics];
-    }
-    return found.diagnostics.filter((record) => record.constituentId === filters.constituentId);
-  }
-};
-
-// src/models/tool-contract.ts
-var CONTRACT_VERSION = "1.2.0";
-
-// src/models/rstool-agent.ts
-var RSToolAgent = class {
-  contractVersion = CONTRACT_VERSION;
-  sessions = new SessionStore();
-  adapter = new SchemaAdapter();
-  evaluation = new ModelAdapter();
-  createSession(initial) {
-    return this.sessions.create(initial, this.contractVersion);
-  }
-  addOrUpdateConstituenta(sessionId, input2) {
-    const envelope = this.sessions.get(sessionId);
-    const { result, diagnostics } = this.adapter.analyzeAgainstSession(envelope.state, input2.draft);
-    const state = this.adapter.mergeStateWithDraft(envelope.state, input2.draft, result);
-    this.sessions.appendDiagnostics(sessionId, diagnostics);
-    return {
-      state,
-      diagnostics
-    };
-  }
-  analyzeExpression(sessionId, input2) {
-    const envelope = this.sessions.get(sessionId);
-    const { result, diagnostics } = this.adapter.analyzeAgainstSession(envelope.state, {
-      id: -1,
-      alias: "_analysis",
-      cstType: input2.cstType,
-      definitionFormal: input2.expression
-    });
-    this.sessions.appendDiagnostics(
-      sessionId,
-      diagnostics.map((item) => ({ ...item, constituentId: void 0 }))
-    );
-    return result;
-  }
-  getFormState(sessionId) {
-    const envelope = this.sessions.get(sessionId);
-    return structuredClone(envelope.state);
-  }
-  listDiagnostics(sessionId, filters) {
-    return this.sessions.listDiagnostics(sessionId, filters);
-  }
-  commitStep(sessionId, message) {
-    return this.sessions.addRevision(sessionId, message);
-  }
-  exportSession(sessionId) {
-    const envelope = this.sessions.get(sessionId);
-    return JSON.stringify(
-      {
-        contractVersion: this.contractVersion,
-        state: envelope.state,
-        diagnostics: envelope.diagnostics
-      },
-      null,
-      2
-    );
-  }
-  importSession(payload) {
-    const parsed = JSON.parse(payload);
-    if (!parsed.state.model) {
-      parsed.state.model = { items: [] };
-    }
-    return this.sessions.create(parsed.state, this.contractVersion);
-  }
-  async setConstituentaValue(sessionId, input2) {
-    const envelope = this.sessions.get(sessionId);
-    return this.evaluation.setConstituentaValue(envelope.state, input2);
-  }
-  async setConstituentaValues(sessionId, input2) {
-    const envelope = this.sessions.get(sessionId);
-    return this.evaluation.setConstituentaValues(envelope.state, input2);
-  }
-  async clearConstituentaValues(sessionId, input2) {
-    const envelope = this.sessions.get(sessionId);
-    return this.evaluation.clearConstituentaValues(envelope.state, input2.items);
-  }
-  getModelState(sessionId) {
-    const envelope = this.sessions.get(sessionId);
-    return structuredClone(envelope.state.model);
-  }
-  evaluateExpression(sessionId, input2) {
-    const envelope = this.sessions.get(sessionId);
-    return this.evaluation.evaluateExpression(envelope.state, input2.expression, input2.cstType);
-  }
-  evaluateConstituenta(sessionId, input2) {
-    const envelope = this.sessions.get(sessionId);
-    return this.evaluation.evaluateConstituenta(envelope.state, input2.constituentId);
-  }
-  recalculateModel(sessionId) {
-    const envelope = this.sessions.get(sessionId);
-    return this.evaluation.recalculateModel(envelope.state);
-  }
-};
-
-// src/wrapper/stdio-wrapper.ts
-var tool = new RSToolAgent();
-var METHODS = [
-  "createSession",
-  "addOrUpdateConstituenta",
-  "analyzeExpression",
-  "getFormState",
-  "listDiagnostics",
-  "commitStep",
-  "exportSession",
-  "importSession",
-  "setConstituentaValue",
-  "setConstituentaValues",
-  "clearConstituentaValues",
-  "getModelState",
-  "evaluateExpression",
-  "evaluateConstituenta",
-  "recalculateModel"
+import { RSToolAgent } from "../models/rstool-agent.js";
+import readline from "node:readline";
+//#region src/wrapper/stdio-wrapper.ts
+const tool = new RSToolAgent();
+const METHODS = [
+	"createSession",
+	"addOrUpdateConstituenta",
+	"analyzeExpression",
+	"getFormState",
+	"listDiagnostics",
+	"commitStep",
+	"exportSession",
+	"importSession",
+	"setConstituentaValue",
+	"setConstituentaValues",
+	"clearConstituentaValues",
+	"getModelState",
+	"evaluateExpression",
+	"evaluateConstituenta",
+	"recalculateModel"
 ];
 function writeResponse(response) {
-  if (!process.stdout.writable || process.stdout.destroyed || process.stdout.writableEnded) {
-    return;
-  }
-  try {
-    process.stdout.write(`${JSON.stringify(response)}
-`);
-  } catch {
-  }
+	if (!process.stdout.writable || process.stdout.destroyed || process.stdout.writableEnded) return;
+	try {
+		process.stdout.write(`${JSON.stringify(response)}\n`);
+	} catch {}
 }
 function asObject(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    return {};
-  }
-  return value;
+	if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+	return value;
 }
-function requiredString(input2, key) {
-  const value = input2[key];
-  if (typeof value !== "string" || value.length === 0) {
-    throw new Error(`Missing or invalid "${key}"`);
-  }
-  return value;
+function requiredString(input, key) {
+	const value = input[key];
+	if (typeof value !== "string" || value.length === 0) throw new Error(`Missing or invalid "${key}"`);
+	return value;
 }
 async function handleRequest(request) {
-  try {
-    const params = asObject(request.params);
-    switch (request.method) {
-      case "ping":
-        return { id: request.id, ok: true, result: { pong: true } };
-      case "methods":
-        return { id: request.id, ok: true, result: METHODS };
-      case "createSession":
-        return {
-          id: request.id,
-          ok: true,
-          result: tool.createSession(params.initial)
-        };
-      case "addOrUpdateConstituenta":
-        return {
-          id: request.id,
-          ok: true,
-          result: tool.addOrUpdateConstituenta(requiredString(params, "sessionId"), params.input)
-        };
-      case "analyzeExpression":
-        return {
-          id: request.id,
-          ok: true,
-          result: tool.analyzeExpression(requiredString(params, "sessionId"), params.input)
-        };
-      case "getFormState":
-        return {
-          id: request.id,
-          ok: true,
-          result: tool.getFormState(requiredString(params, "sessionId"))
-        };
-      case "listDiagnostics":
-        return {
-          id: request.id,
-          ok: true,
-          result: tool.listDiagnostics(requiredString(params, "sessionId"), params.filters)
-        };
-      case "commitStep":
-        return {
-          id: request.id,
-          ok: true,
-          result: tool.commitStep(requiredString(params, "sessionId"), params.message)
-        };
-      case "exportSession":
-        return {
-          id: request.id,
-          ok: true,
-          result: tool.exportSession(requiredString(params, "sessionId"))
-        };
-      case "importSession":
-        return {
-          id: request.id,
-          ok: true,
-          result: tool.importSession(requiredString(params, "payload"))
-        };
-      case "setConstituentaValue":
-        return {
-          id: request.id,
-          ok: true,
-          result: await tool.setConstituentaValue(requiredString(params, "sessionId"), params.input)
-        };
-      case "setConstituentaValues":
-        return {
-          id: request.id,
-          ok: true,
-          result: await tool.setConstituentaValues(requiredString(params, "sessionId"), params.input)
-        };
-      case "clearConstituentaValues":
-        return {
-          id: request.id,
-          ok: true,
-          result: await tool.clearConstituentaValues(requiredString(params, "sessionId"), params.input)
-        };
-      case "getModelState":
-        return {
-          id: request.id,
-          ok: true,
-          result: tool.getModelState(requiredString(params, "sessionId"))
-        };
-      case "evaluateExpression":
-        return {
-          id: request.id,
-          ok: true,
-          result: tool.evaluateExpression(requiredString(params, "sessionId"), params.input)
-        };
-      case "evaluateConstituenta":
-        return {
-          id: request.id,
-          ok: true,
-          result: tool.evaluateConstituenta(requiredString(params, "sessionId"), params.input)
-        };
-      case "recalculateModel":
-        return {
-          id: request.id,
-          ok: true,
-          result: tool.recalculateModel(requiredString(params, "sessionId"))
-        };
-      default:
-        return {
-          id: request.id ?? null,
-          ok: false,
-          error: {
-            code: "METHOD_NOT_FOUND",
-            message: `Unknown method: ${request.method}`
-          }
-        };
-    }
-  } catch (error) {
-    return {
-      id: request.id ?? null,
-      ok: false,
-      error: {
-        code: "INTERNAL_ERROR",
-        message: error instanceof Error ? error.message : "Unknown error",
-        details: error
-      }
-    };
-  }
+	try {
+		const params = asObject(request.params);
+		switch (request.method) {
+			case "ping": return {
+				id: request.id,
+				ok: true,
+				result: { pong: true }
+			};
+			case "methods": return {
+				id: request.id,
+				ok: true,
+				result: METHODS
+			};
+			case "createSession": return {
+				id: request.id,
+				ok: true,
+				result: tool.createSession(params.initial)
+			};
+			case "addOrUpdateConstituenta": return {
+				id: request.id,
+				ok: true,
+				result: tool.addOrUpdateConstituenta(requiredString(params, "sessionId"), params.input)
+			};
+			case "analyzeExpression": return {
+				id: request.id,
+				ok: true,
+				result: tool.analyzeExpression(requiredString(params, "sessionId"), params.input)
+			};
+			case "getFormState": return {
+				id: request.id,
+				ok: true,
+				result: tool.getFormState(requiredString(params, "sessionId"))
+			};
+			case "listDiagnostics": return {
+				id: request.id,
+				ok: true,
+				result: tool.listDiagnostics(requiredString(params, "sessionId"), params.filters)
+			};
+			case "commitStep": return {
+				id: request.id,
+				ok: true,
+				result: tool.commitStep(requiredString(params, "sessionId"), params.message)
+			};
+			case "exportSession": return {
+				id: request.id,
+				ok: true,
+				result: tool.exportSession(requiredString(params, "sessionId"))
+			};
+			case "importSession": return {
+				id: request.id,
+				ok: true,
+				result: tool.importSession(requiredString(params, "payload"))
+			};
+			case "setConstituentaValue": return {
+				id: request.id,
+				ok: true,
+				result: await tool.setConstituentaValue(requiredString(params, "sessionId"), params.input)
+			};
+			case "setConstituentaValues": return {
+				id: request.id,
+				ok: true,
+				result: await tool.setConstituentaValues(requiredString(params, "sessionId"), params.input)
+			};
+			case "clearConstituentaValues": return {
+				id: request.id,
+				ok: true,
+				result: await tool.clearConstituentaValues(requiredString(params, "sessionId"), params.input)
+			};
+			case "getModelState": return {
+				id: request.id,
+				ok: true,
+				result: tool.getModelState(requiredString(params, "sessionId"))
+			};
+			case "evaluateExpression": return {
+				id: request.id,
+				ok: true,
+				result: tool.evaluateExpression(requiredString(params, "sessionId"), params.input)
+			};
+			case "evaluateConstituenta": return {
+				id: request.id,
+				ok: true,
+				result: tool.evaluateConstituenta(requiredString(params, "sessionId"), params.input)
+			};
+			case "recalculateModel": return {
+				id: request.id,
+				ok: true,
+				result: tool.recalculateModel(requiredString(params, "sessionId"))
+			};
+			default: return {
+				id: request.id ?? null,
+				ok: false,
+				error: {
+					code: "METHOD_NOT_FOUND",
+					message: `Unknown method: ${request.method}`
+				}
+			};
+		}
+	} catch (error) {
+		return {
+			id: request.id ?? null,
+			ok: false,
+			error: {
+				code: "INTERNAL_ERROR",
+				message: error instanceof Error ? error.message : "Unknown error",
+				details: error
+			}
+		};
+	}
 }
-var input = readline.createInterface({
-  input: process.stdin,
-  crlfDelay: Infinity
+const input = readline.createInterface({
+	input: process.stdin,
+	crlfDelay: Infinity
 });
 writeResponse({
-  id: null,
-  ok: true,
-  result: {
-    ready: true,
-    wrapper: "rstool-stdio",
-    contractVersion: tool.contractVersion
-  }
+	id: null,
+	ok: true,
+	result: {
+		ready: true,
+		wrapper: "rstool-stdio",
+		contractVersion: tool.contractVersion
+	}
 });
 input.on("line", (line) => {
-  if (!line.trim()) {
-    return;
-  }
-  try {
-    const request = JSON.parse(line);
-    if (!("id" in request) || !("method" in request)) {
-      throw new Error('Request must include "id" and "method"');
-    }
-    void handleRequest(request).then(writeResponse);
-  } catch (error) {
-    writeResponse({
-      id: null,
-      ok: false,
-      error: {
-        code: "BAD_REQUEST",
-        message: error instanceof Error ? error.message : "Invalid JSON"
-      }
-    });
-  }
+	if (!line.trim()) return;
+	try {
+		const request = JSON.parse(line);
+		if (!("id" in request) || !("method" in request)) throw new Error("Request must include \"id\" and \"method\"");
+		handleRequest(request).then(writeResponse);
+	} catch (error) {
+		writeResponse({
+			id: null,
+			ok: false,
+			error: {
+				code: "BAD_REQUEST",
+				message: error instanceof Error ? error.message : "Invalid JSON"
+			}
+		});
+	}
 });
+//#endregion
+export {};
+
 //# sourceMappingURL=stdio-wrapper.js.map