@cosyte/cli 0.0.1

package/dist/bin/cosyte.mjs

@@ -0,0 +1,1783 @@
+#!/usr/bin/env node
+import { parseArgs } from 'util';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { readFile } from 'fs/promises';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/core/exit-codes.ts
+var EXIT;
+var init_exit_codes = __esm({
+  "src/core/exit-codes.ts"() {
+    EXIT = {
+      /** Success: the operation completed; `validate` found the input **valid**. */
+      OK: 0,
+      /** Operation-level failure: `validate` found the input **invalid** (parseable but non-conformant):
+       * a real, expected CI signal that the message is bad and the tool worked. Never emitted for
+       * unparseable input (that is `DATAERR`). */
+      INVALID: 1,
+      /** Usage error: unknown command, bad flag, missing argument (`EX_USAGE`). */
+      USAGE: 2,
+      /** Data error: input could not be parsed or its format could not be detected (`EX_DATAERR`). */
+      DATAERR: 65,
+      /** No input: the named file does not exist or is unreadable (`EX_NOINPUT`). */
+      NOINPUT: 66,
+      /** Unavailable: a required capability is not yet built (e.g. `redact` before `@cosyte/deid`), a
+       * distinct non-zero signal that is never a fake success (`EX_UNAVAILABLE`). */
+      UNAVAILABLE: 69,
+      /** Internal error: an unexpected exception (a bug), distinct from a handled bad input (`EX_SOFTWARE`). */
+      SOFTWARE: 70
+    };
+  }
+});
+
+// src/core/diagnostics.ts
+function formatDiagnostic(err) {
+  return `cosyte: ${err.code}: ${err.message}`;
+}
+function errorResult(err) {
+  return { stdout: "", stderr: `${formatDiagnostic(err)}
+`, exit: err.exit };
+}
+function toCliError(err) {
+  if (err instanceof CliError) return err;
+  return new CliError(
+    CLI_CODES.CLI_INTERNAL,
+    EXIT.SOFTWARE,
+    "an unexpected internal error occurred (no input is echoed)"
+  );
+}
+var CLI_CODES, CliError;
+var init_diagnostics = __esm({
+  "src/core/diagnostics.ts"() {
+    init_exit_codes();
+    CLI_CODES = {
+      /** A required argument was missing or a flag was invalid. Exit `2`. */
+      CLI_USAGE: "CLI_USAGE",
+      /** The named file does not exist or could not be read. Exit `66`. */
+      CLI_NO_INPUT: "CLI_NO_INPUT",
+      /** The input was empty, no bytes to detect or parse. Exit `65`. */
+      CLI_EMPTY_INPUT: "CLI_EMPTY_INPUT",
+      /** No format signature matched; the CLI will not guess. Names the candidates, never the bytes. Exit `65`. */
+      CLI_FORMAT_UNDETECTED: "CLI_FORMAT_UNDETECTED",
+      /** More than one format signature matched; the CLI will not guess. Names the candidates, never the bytes. Exit `65`. */
+      CLI_FORMAT_AMBIGUOUS: "CLI_FORMAT_AMBIGUOUS",
+      /** A recognised format whose parser does not support the requested operation (e.g. `parse` on a
+       * format wired only for `inspect`). Names the format + operation, never the bytes. Exit `65`. */
+      CLI_FORMAT_UNSUPPORTED: "CLI_FORMAT_UNSUPPORTED",
+      /** The optional parser package for a recognised format is not installed. The six breadth parsers
+       * (dicom/x12/ccda/ncpdp/astm/mllp) are `optionalDependencies`: normally installed, but if
+       * one is absent the CLI degrades to this value-free signal rather than crashing. Exit `69`. */
+      CLI_PARSER_UNAVAILABLE: "CLI_PARSER_UNAVAILABLE",
+      /** The wrapped parser rejected the input. Positional context only, never the offending bytes. Exit `65`. */
+      CLI_PARSE_FAILED: "CLI_PARSE_FAILED",
+      /** The BYO ConceptMap supplied to `map-codes` is not valid JSON or not a loadable FHIR ConceptMap.
+       * Names the stable terminology-loader code, never the map's bytes. Exit `65`. */
+      CLI_MAP_INVALID: "CLI_MAP_INVALID",
+      /** A command whose ground-layer library is not yet built (e.g. `redact` before `@cosyte/deid`
+       * ships). Never a fake success: a distinct, value-free "unavailable" signal. Exit `69`. */
+      CLI_NOT_IMPLEMENTED: "CLI_NOT_IMPLEMENTED",
+      /** An unexpected internal error (a bug). Exit `70`. */
+      CLI_INTERNAL: "CLI_INTERNAL"
+    };
+    CliError = class extends Error {
+      /** The stable diagnostic code. */
+      code;
+      /** The exit code this error resolves the invocation to. */
+      exit;
+      /**
+       * @param code - A stable {@link CliCode}.
+       * @param exit - The {@link ExitCode} to resolve to.
+       * @param message - A **value-free** explanation (positional/structural context only, never PHI).
+       */
+      constructor(code, exit, message) {
+        super(message);
+        this.name = "CliError";
+        this.code = code;
+        this.exit = exit;
+      }
+    };
+  }
+});
+
+// src/core/format.ts
+function leadingText(bytes) {
+  const slice = bytes.subarray(0, SNIFF_BYTES);
+  let text = new TextDecoder("utf-8", { fatal: false }).decode(slice);
+  if (text.charCodeAt(0) === 65279) text = text.slice(1);
+  return text;
+}
+function trimLeading(prefix) {
+  return prefix.replace(/^[ \t\r\n\f]+/, "");
+}
+function isDelimiter(ch) {
+  if (ch === void 0) return false;
+  const code = ch.charCodeAt(0);
+  return code > 32 && code < 127 && !/[A-Za-z0-9]/.test(ch);
+}
+function looksLikeHl7(prefix) {
+  const s = trimLeading(prefix);
+  return s.startsWith("MSH") && isDelimiter(s[3]);
+}
+function looksLikeMllp(_prefix, bytes) {
+  return bytes[0] === 11;
+}
+function looksLikeFhir(prefix) {
+  const s = trimLeading(prefix);
+  if (!s.startsWith("{")) return false;
+  return /"resourceType"\s*:\s*"/.test(s);
+}
+function looksLikeX12(prefix) {
+  const s = trimLeading(prefix);
+  return s.startsWith("ISA") && isDelimiter(s[3]);
+}
+function looksLikeAstm(prefix) {
+  const s = trimLeading(prefix);
+  if (!s.startsWith("H") || s.length < 5) return false;
+  return isDelimiter(s[1]) && isDelimiter(s[2]) && isDelimiter(s[3]) && isDelimiter(s[4]);
+}
+function looksLikeCcda(prefix) {
+  return /<ClinicalDocument[\s>]/.test(prefix);
+}
+function looksLikeNcpdp(prefix) {
+  return /<Message[\s>]/.test(prefix) && /ncpdp/i.test(prefix);
+}
+function looksLikeDicom(_prefix, bytes) {
+  if (bytes.length < 132) return false;
+  return bytes[128] === 68 && bytes[129] === 73 && bytes[130] === 67 && bytes[131] === 77;
+}
+function detectFormat(bytes) {
+  if (bytes.length === 0) return classifyCandidates([]);
+  const prefix = leadingText(bytes);
+  const candidates = SIGNATURES.filter((sig) => sig.match(prefix, bytes)).map((sig) => sig.format);
+  return classifyCandidates(candidates);
+}
+function classifyCandidates(candidates) {
+  const [first, second] = candidates;
+  if (second !== void 0) return { format: null, confidence: "ambiguous", candidates };
+  if (first !== void 0) return { format: first, confidence: "certain", candidates };
+  return { format: null, confidence: "none", candidates: [] };
+}
+function detectionError(detected) {
+  if (detected.confidence === "ambiguous") {
+    return new CliError(
+      CLI_CODES.CLI_FORMAT_AMBIGUOUS,
+      EXIT.DATAERR,
+      `input matched multiple formats (${detected.candidates.join(", ")}); disambiguate with --format`
+    );
+  }
+  return new CliError(
+    CLI_CODES.CLI_FORMAT_UNDETECTED,
+    EXIT.DATAERR,
+    `could not detect the input format; re-run with --format (detectable: ${DETECTABLE_FORMATS.join(", ")})`
+  );
+}
+function asCosyteFormat(value) {
+  return KNOWN_FORMATS.includes(value) ? value : null;
+}
+var SNIFF_BYTES, SIGNATURES, DETECTABLE_FORMATS, KNOWN_FORMATS;
+var init_format = __esm({
+  "src/core/format.ts"() {
+    init_diagnostics();
+    init_exit_codes();
+    SNIFF_BYTES = 512;
+    SIGNATURES = [
+      { format: "hl7", match: (prefix) => looksLikeHl7(prefix) },
+      { format: "mllp", match: (prefix, bytes) => looksLikeMllp(prefix, bytes) },
+      { format: "fhir", match: (prefix) => looksLikeFhir(prefix) },
+      { format: "x12", match: (prefix) => looksLikeX12(prefix) },
+      { format: "astm", match: (prefix) => looksLikeAstm(prefix) },
+      { format: "ccda", match: (prefix) => looksLikeCcda(prefix) },
+      { format: "ncpdp", match: (prefix) => looksLikeNcpdp(prefix) },
+      { format: "dicom", match: (prefix, bytes) => looksLikeDicom(prefix, bytes) }
+    ];
+    DETECTABLE_FORMATS = SIGNATURES.map((s) => s.format);
+    KNOWN_FORMATS = [
+      "hl7",
+      "fhir",
+      "dicom",
+      "x12",
+      "ccda",
+      "ncpdp",
+      "astm",
+      "mllp"
+    ];
+  }
+});
+
+// src/core/findings.ts
+function formatHl7Position(pos) {
+  let out = `seg[${String(pos.segmentIndex)}]`;
+  if (pos.fieldIndex !== void 0) out += `.field[${String(pos.fieldIndex)}]`;
+  if (pos.repetitionIndex !== void 0) out += `.rep[${String(pos.repetitionIndex)}]`;
+  if (pos.componentIndex !== void 0) out += `.comp[${String(pos.componentIndex)}]`;
+  if (pos.subcomponentIndex !== void 0) out += `.sub[${String(pos.subcomponentIndex)}]`;
+  return out;
+}
+var init_findings = __esm({
+  "src/core/findings.ts"() {
+  }
+});
+
+// src/core/parsers.ts
+function supportsOp(format, op) {
+  return OP_SUPPORT[format].has(op);
+}
+function formatsSupporting(op) {
+  return Object.keys(OP_SUPPORT).filter((f) => OP_SUPPORT[f].has(op)).sort();
+}
+function valueFreeLocator(pos) {
+  if (typeof pos !== "object" || pos === null) return "?";
+  const parts = [];
+  for (const [k, v] of Object.entries(pos)) {
+    if (typeof v === "number") parts.push(`${k}[${String(v)}]`);
+  }
+  return parts.length > 0 ? parts.join(".") : "?";
+}
+function anyError(findings) {
+  return findings.some((f) => ERROR_SEVERITIES.has(f.severity));
+}
+async function loadOptional(format, load) {
+  try {
+    return await load();
+  } catch (e) {
+    if (isModuleNotFound(e)) {
+      throw new CliError(
+        CLI_CODES.CLI_PARSER_UNAVAILABLE,
+        EXIT.UNAVAILABLE,
+        `the @cosyte/${format} parser is not installed; install it to use this format (it is an optional dependency)`
+      );
+    }
+    throw e;
+  }
+}
+function isModuleNotFound(e) {
+  if (typeof e !== "object" || e === null) return false;
+  const code = "code" in e ? e.code : void 0;
+  if (code === "ERR_MODULE_NOT_FOUND" || code === "MODULE_NOT_FOUND") return true;
+  const message = "message" in e && typeof e.message === "string" ? e.message : "";
+  return /Cannot find (package|module)|Failed to (load|resolve)/i.test(message);
+}
+async function parseFormat(format, bytes) {
+  switch (format) {
+    case "hl7": {
+      const { parseHL7 } = await import('@cosyte/hl7');
+      const msg = parseHL7(Buffer.from(bytes));
+      return {
+        model: msg.toJSON(),
+        warnings: msg.warnings.map((w) => ({ code: w.code, position: w.position }))
+      };
+    }
+    case "fhir": {
+      const { parseResource, serializeResource } = await import('@cosyte/fhir');
+      const text = decode(bytes);
+      const { resource, issues } = parseResource(text);
+      const model = JSON.parse(serializeResource(resource));
+      return {
+        model,
+        warnings: issues.map((i) => ({
+          code: i.code,
+          severity: i.severity,
+          expression: i.expression
+        }))
+      };
+    }
+    case "x12": {
+      const { parseX12 } = await loadOptional("x12", () => import('@cosyte/x12'));
+      const ix = parseX12(Buffer.from(bytes));
+      return {
+        model: ix,
+        warnings: ix.warnings.map((w) => ({ code: w.code, position: w.position }))
+      };
+    }
+    case "astm": {
+      const { parseAstmRecords } = await loadOptional("astm", () => import('@cosyte/astm'));
+      const msg = parseAstmRecords(decode(bytes));
+      return {
+        model: msg,
+        warnings: msg.warnings.map((w) => ({ code: w.code, position: w.position }))
+      };
+    }
+    case "ncpdp": {
+      const { parseScript } = await loadOptional("ncpdp", () => import('@cosyte/ncpdp'));
+      const msg = parseScript(decode(bytes));
+      return {
+        model: msg,
+        warnings: msg.warnings.map((w) => ({ code: w.code, position: w.position }))
+      };
+    }
+    case "dicom":
+    case "ccda":
+    case "mllp":
+      throw unsupportedInternal(format, "parse");
+  }
+}
+async function inspectFormat(format, bytes) {
+  switch (format) {
+    case "hl7": {
+      const { parseHL7 } = await import('@cosyte/hl7');
+      const msg = parseHL7(Buffer.from(bytes));
+      const segments = {};
+      const all = msg.allSegments();
+      for (const seg of all) segments[seg.type] = (segments[seg.type] ?? 0) + 1;
+      return {
+        format: "hl7",
+        messageType: msg.meta.type ?? null,
+        version: msg.meta.version ?? null,
+        segmentCount: all.length,
+        segments,
+        warningCount: msg.warnings.length
+      };
+    }
+    case "fhir": {
+      const { parseResource, resourceType, readBundle } = await import('@cosyte/fhir');
+      const { resource, issues } = parseResource(decode(bytes));
+      const rt = resourceType(resource) ?? null;
+      if (rt === "Bundle") {
+        const bundle = readBundle(resource);
+        const entryResourceTypes = {};
+        for (const e of bundle.entries) {
+          const t = e.resourceType ?? "(none)";
+          entryResourceTypes[t] = (entryResourceTypes[t] ?? 0) + 1;
+        }
+        return {
+          format: "fhir",
+          resourceType: rt,
+          bundleType: bundle.type ?? null,
+          entryCount: bundle.entries.length,
+          entryResourceTypes,
+          issueCount: issues.length
+        };
+      }
+      return { format: "fhir", resourceType: rt, issueCount: issues.length };
+    }
+    case "x12": {
+      const { parseX12 } = await loadOptional("x12", () => import('@cosyte/x12'));
+      const ix = parseX12(Buffer.from(bytes));
+      const transactionSetIds = {};
+      let transactionCount = 0;
+      let segmentCount = 0;
+      for (const g of ix.groups) {
+        for (const t of g.transactions) {
+          transactionCount += 1;
+          segmentCount += t.segments.length;
+          const id = t.st.elements[1] ?? "(unknown)";
+          transactionSetIds[id] = (transactionSetIds[id] ?? 0) + 1;
+        }
+      }
+      return {
+        format: "x12",
+        groupCount: ix.groups.length,
+        transactionCount,
+        transactionSetIds,
+        segmentCount,
+        warningCount: ix.warnings.length
+      };
+    }
+    case "astm": {
+      const { parseAstmRecords } = await loadOptional("astm", () => import('@cosyte/astm'));
+      const msg = parseAstmRecords(decode(bytes));
+      const recordTypes = {};
+      for (const r of msg.records) recordTypes[r.type] = (recordTypes[r.type] ?? 0) + 1;
+      return {
+        format: "astm",
+        messageKind: msg.classification.kind,
+        recordCount: msg.records.length,
+        recordTypes,
+        warningCount: msg.warnings.length
+      };
+    }
+    case "ccda": {
+      const { parseCcda } = await loadOptional("ccda", () => import('@cosyte/ccda'));
+      const doc = parseCcda(decode(bytes));
+      const sectionCodes = [];
+      for (const s of doc.sections) {
+        const code = s.code?.code;
+        if (typeof code === "string") sectionCodes.push(code);
+      }
+      return {
+        format: "ccda",
+        documentType: doc.documentType ?? null,
+        sectionCount: doc.sections.length,
+        sectionCodes,
+        warningCount: doc.warnings.length
+      };
+    }
+    case "dicom": {
+      const { parseDicom } = await loadOptional("dicom", () => import('@cosyte/dicom'));
+      let warningCount = 0;
+      const ds = parseDicom(Buffer.from(bytes), { onWarning: () => warningCount += 1 });
+      return {
+        format: "dicom",
+        sopClassUid: ds.fileMeta?.mediaStorageSOPClassUID ?? null,
+        transferSyntaxUid: ds.fileMeta?.transferSyntaxUID ?? null,
+        elementCount: ds.elements().length,
+        warningCount
+      };
+    }
+    case "ncpdp": {
+      const { parseScript } = await loadOptional("ncpdp", () => import('@cosyte/ncpdp'));
+      const msg = parseScript(decode(bytes));
+      return {
+        format: "ncpdp",
+        standard: "SCRIPT",
+        messageType: msg.body.kind ?? null,
+        version: msg.header.version ?? null,
+        warningCount: msg.warnings.length
+      };
+    }
+    case "mllp": {
+      const { payloads, warningCount } = await deframeMllp(bytes);
+      return { format: "mllp", frameCount: payloads.length, warningCount };
+    }
+  }
+}
+async function fmtFormat(format, bytes) {
+  switch (format) {
+    case "hl7": {
+      const { parseHL7 } = await import('@cosyte/hl7');
+      const msg = parseHL7(Buffer.from(bytes));
+      return { output: msg.toString(), warningCount: msg.warnings.length };
+    }
+    case "fhir": {
+      const { parseResource, serializeResource } = await import('@cosyte/fhir');
+      const { resource, issues } = parseResource(decode(bytes));
+      return { output: serializeResource(resource), warningCount: issues.length };
+    }
+    case "x12": {
+      const { parseX12, serializeX12 } = await loadOptional("x12", () => import('@cosyte/x12'));
+      const ix = parseX12(Buffer.from(bytes));
+      return { output: serializeX12(ix), warningCount: ix.warnings.length };
+    }
+    case "astm": {
+      const { parseAstmRecords, serializeAstmRecords } = await loadOptional(
+        "astm",
+        () => import('@cosyte/astm')
+      );
+      const msg = parseAstmRecords(decode(bytes));
+      return { output: serializeAstmRecords(msg), warningCount: msg.warnings.length };
+    }
+    case "ccda": {
+      const { parseCcda, serializeCcda } = await loadOptional("ccda", () => import('@cosyte/ccda'));
+      const doc = parseCcda(decode(bytes));
+      return { output: serializeCcda(doc), warningCount: doc.warnings.length };
+    }
+    case "ncpdp": {
+      const { parseScript, serializeScript } = await loadOptional(
+        "ncpdp",
+        () => import('@cosyte/ncpdp')
+      );
+      const msg = parseScript(decode(bytes));
+      return { output: serializeScript(msg), warningCount: msg.warnings.length };
+    }
+    case "dicom":
+    case "mllp":
+      throw unsupportedInternal(format, "fmt");
+  }
+}
+async function validateFormat(format, bytes) {
+  switch (format) {
+    case "fhir": {
+      const { parseResource, validateResource } = await import('@cosyte/fhir');
+      const { resource, issues } = parseResource(decode(bytes));
+      const validation = validateResource(resource);
+      const findings = [
+        ...issues.map((i) => finding(i.code, i.severity, i.expression)),
+        ...validation.issues.map((i) => finding(i.code, i.severity, i.expression, i.constraint))
+      ];
+      return { findings, valid: !anyError(findings) };
+    }
+    case "hl7": {
+      const { parseHL7 } = await import('@cosyte/hl7');
+      const msg = parseHL7(Buffer.from(bytes));
+      const findings = msg.warnings.map(
+        (w) => finding(w.code, "warning", formatHl7Position(w.position))
+      );
+      return { findings, valid: !anyError(findings) };
+    }
+    case "x12": {
+      const { parseX12 } = await loadOptional("x12", () => import('@cosyte/x12'));
+      const ix = parseX12(Buffer.from(bytes));
+      const findings = ix.warnings.map(
+        (w) => finding(w.code, "warning", valueFreeLocator(w.position))
+      );
+      return { findings, valid: !anyError(findings) };
+    }
+    case "astm": {
+      const { parseAstmRecords } = await loadOptional("astm", () => import('@cosyte/astm'));
+      const msg = parseAstmRecords(decode(bytes));
+      const findings = msg.warnings.map(
+        (w) => finding(w.code, "warning", valueFreeLocator(w.position))
+      );
+      return { findings, valid: !anyError(findings) };
+    }
+    case "ccda": {
+      const { parseCcda } = await loadOptional("ccda", () => import('@cosyte/ccda'));
+      const doc = parseCcda(decode(bytes));
+      const findings = doc.warnings.map(
+        (w) => finding(w.code, "warning", valueFreeLocator(w.position))
+      );
+      return { findings, valid: !anyError(findings) };
+    }
+    case "dicom": {
+      const { parseDicom } = await loadOptional("dicom", () => import('@cosyte/dicom'));
+      const findings = [];
+      parseDicom(Buffer.from(bytes), {
+        onWarning: (w) => findings.push(finding(w.code, "warning", valueFreeLocator(w.position)))
+      });
+      return { findings, valid: !anyError(findings) };
+    }
+    case "ncpdp": {
+      const { parseScript } = await loadOptional("ncpdp", () => import('@cosyte/ncpdp'));
+      const msg = parseScript(decode(bytes));
+      const findings = msg.warnings.map(
+        (w) => finding(w.code, "warning", valueFreeLocator(w.position))
+      );
+      return { findings, valid: !anyError(findings) };
+    }
+    case "mllp":
+      throw unsupportedInternal(format, "validate");
+  }
+}
+async function deframeMllp(bytes) {
+  if (bytes.lastIndexOf(11) > bytes.lastIndexOf(28)) {
+    throw new CliError(
+      CLI_CODES.CLI_PARSE_FAILED,
+      EXIT.DATAERR,
+      "truncated MLLP stream: an unterminated frame at the end of input (no closing FS/CR)"
+    );
+  }
+  const { FrameReader } = await loadOptional("mllp", () => import('@cosyte/mllp'));
+  const payloads = [];
+  let warningCount = 0;
+  const reader = new FrameReader({
+    onFrame: (payload) => payloads.push(Buffer.from(payload)),
+    onWarning: () => warningCount += 1
+  });
+  reader.push(Buffer.from(bytes));
+  return { payloads, warningCount };
+}
+function decode(bytes) {
+  return new TextDecoder("utf-8", { fatal: false }).decode(bytes);
+}
+function finding(code, severity, location, constraint) {
+  const loc = constraint !== void 0 ? `${location} (${constraint})` : location;
+  return { code, severity, location: loc };
+}
+function unsupportedInternal(format, op) {
+  return new CliError(
+    CLI_CODES.CLI_FORMAT_UNSUPPORTED,
+    EXIT.DATAERR,
+    `format '${format}' does not support \`${op}\``
+  );
+}
+var OP_SUPPORT, ERROR_SEVERITIES;
+var init_parsers = __esm({
+  "src/core/parsers.ts"() {
+    init_diagnostics();
+    init_exit_codes();
+    init_findings();
+    OP_SUPPORT = {
+      hl7: /* @__PURE__ */ new Set(["parse", "inspect", "fmt", "validate"]),
+      fhir: /* @__PURE__ */ new Set(["parse", "inspect", "fmt", "validate"]),
+      x12: /* @__PURE__ */ new Set(["parse", "inspect", "fmt", "validate"]),
+      astm: /* @__PURE__ */ new Set(["parse", "inspect", "fmt", "validate"]),
+      ncpdp: /* @__PURE__ */ new Set(["parse", "inspect", "fmt", "validate"]),
+      ccda: /* @__PURE__ */ new Set(["inspect", "fmt", "validate"]),
+      dicom: /* @__PURE__ */ new Set(["inspect", "validate"]),
+      mllp: /* @__PURE__ */ new Set(["parse", "inspect"])
+    };
+    ERROR_SEVERITIES = /* @__PURE__ */ new Set(["error", "fatal"]);
+  }
+});
+
+// src/core/input.ts
+async function resolveInput(source, formatOverride, deps2, op) {
+  if (source === void 0) {
+    return fail(
+      new CliError(
+        CLI_CODES.CLI_USAGE,
+        EXIT.USAGE,
+        "missing <file> argument; pass a path or `-` to read stdin"
+      )
+    );
+  }
+  let bytes;
+  try {
+    bytes = source === "-" ? await deps2.readStdin() : await deps2.readFile(source);
+  } catch (e) {
+    if (e instanceof CliError) return fail(e);
+    throw e;
+  }
+  if (bytes.length === 0) {
+    return fail(new CliError(CLI_CODES.CLI_EMPTY_INPUT, EXIT.DATAERR, "input is empty"));
+  }
+  let format;
+  if (formatOverride !== void 0) {
+    const narrowed = asCosyteFormat(formatOverride);
+    if (narrowed === null) {
+      return fail(
+        new CliError(
+          CLI_CODES.CLI_USAGE,
+          EXIT.USAGE,
+          "unknown --format value; expected one of hl7, fhir, dicom, x12, ccda, ncpdp, astm, mllp"
+        )
+      );
+    }
+    format = narrowed;
+  } else {
+    const detected = detectFormat(bytes);
+    if (detected.format === null) return fail(detectionError(detected));
+    format = detected.format;
+  }
+  if (!supportsOp(format, op)) {
+    return fail(
+      new CliError(
+        CLI_CODES.CLI_FORMAT_UNSUPPORTED,
+        EXIT.DATAERR,
+        `format '${format}' does not support \`${op}\` in this CLI build (${op} supports: ${formatsSupporting(op).join(", ")})`
+      )
+    );
+  }
+  return { ok: true, input: { format, bytes } };
+}
+function fail(e) {
+  return { ok: false, result: errorResult(e) };
+}
+var init_input = __esm({
+  "src/core/input.ts"() {
+    init_format();
+    init_diagnostics();
+    init_exit_codes();
+    init_parsers();
+  }
+});
+
+// src/core/phi.ts
+function extractPhiPosture(argv) {
+  const showValues = argv.includes(UNSAFE_SHOW_VALUES_FLAG);
+  const cleaned = argv.filter((a) => a !== UNSAFE_SHOW_VALUES_FLAG);
+  return { posture: showValues ? SHOW_VALUES : VALUE_FREE, argv: cleaned };
+}
+function unsafeInputSuffix(bytes, posture) {
+  if (!posture.showValues) return "";
+  const text = new TextDecoder("utf-8", { fatal: false }).decode(bytes.subarray(0, UNSAFE_EXCERPT_MAX)).replace(/[\r\n\t]+/g, " ").trim();
+  if (text.length === 0) return "";
+  return ` [unsafe-show-values] offending input (first ${String(UNSAFE_EXCERPT_MAX)} bytes): ${text}`;
+}
+var VALUE_FREE, SHOW_VALUES, UNSAFE_SHOW_VALUES_FLAG, UNSAFE_EXCERPT_MAX;
+var init_phi = __esm({
+  "src/core/phi.ts"() {
+    VALUE_FREE = { showValues: false };
+    SHOW_VALUES = { showValues: true };
+    UNSAFE_SHOW_VALUES_FLAG = "--unsafe-show-values";
+    UNSAFE_EXCERPT_MAX = 200;
+  }
+});
+
+// src/core/wrap.ts
+function extractStableCode(e) {
+  if (typeof e === "object" && e !== null && "code" in e) {
+    const raw = e.code;
+    if (typeof raw === "string" && /^[A-Z][A-Z0-9_]*$/.test(raw)) return raw;
+  }
+  return null;
+}
+function parseFailureResult(format, bytes, posture, e) {
+  const code = extractStableCode(e);
+  const detail = code === null ? "" : ` (${code})`;
+  const suffix = unsafeInputSuffix(bytes, posture);
+  return {
+    stdout: "",
+    stderr: `cosyte: ${CLI_CODES.CLI_PARSE_FAILED}: the ${format} parser rejected the input${detail}${suffix}
+`,
+    exit: EXIT.DATAERR
+  };
+}
+var init_wrap = __esm({
+  "src/core/wrap.ts"() {
+    init_diagnostics();
+    init_exit_codes();
+    init_phi();
+  }
+});
+async function convertCommand(args, deps2, posture = VALUE_FREE) {
+  let values;
+  let positionals;
+  try {
+    const parsed = parseArgs({ args, options: CONVERT_OPTIONS, allowPositionals: true });
+    values = parsed.values;
+    positionals = parsed.positionals;
+  } catch {
+    return errorResult(
+      new CliError(
+        CLI_CODES.CLI_USAGE,
+        EXIT.USAGE,
+        "invalid arguments to `convert` (see `cosyte convert --help`)"
+      )
+    );
+  }
+  if (values.to === void 0) {
+    return errorResult(
+      new CliError(CLI_CODES.CLI_USAGE, EXIT.USAGE, "convert requires --to fhir (the only target)")
+    );
+  }
+  if (values.to !== SUPPORTED_TARGET) {
+    return errorResult(
+      new CliError(
+        CLI_CODES.CLI_USAGE,
+        EXIT.USAGE,
+        `unsupported --to '${values.to}'; only --to fhir is supported (HL7 v2 \u2192 FHIR R4)`
+      )
+    );
+  }
+  const resolved = await resolveInput(positionals[0], values.format, deps2, "parse");
+  if (!resolved.ok) return resolved.result;
+  const { format, bytes } = resolved.input;
+  if (format !== "hl7") {
+    return errorResult(
+      new CliError(
+        CLI_CODES.CLI_FORMAT_UNSUPPORTED,
+        EXIT.DATAERR,
+        `convert reads HL7 v2 and writes FHIR R4; the input is '${format}', not an HL7 v2 source`
+      )
+    );
+  }
+  const outcome = await runConvert(bytes, posture);
+  if (!outcome.ok) return outcome.result;
+  const conversion = outcome.conversion;
+  const { hasError, report } = convertOutcome(conversion.findings);
+  const exit = hasError ? EXIT.INVALID : EXIT.OK;
+  if (values.json === true) {
+    const body = {
+      format: SUPPORTED_TARGET,
+      bundle: JSON.parse(conversion.bundleText),
+      findings: conversion.findings
+    };
+    return { stdout: `${JSON.stringify(body)}
+`, stderr: "", exit };
+  }
+  const stderr = values.quiet === true ? "" : report;
+  return { stdout: `${conversion.bundleText}
+`, stderr, exit };
+}
+async function runConvert(bytes, posture) {
+  const [{ parseHL7 }, { toFhir }, { serializeResource }] = await Promise.all([
+    import('@cosyte/hl7'),
+    import('@cosyte/transform'),
+    import('@cosyte/fhir')
+  ]);
+  let msg;
+  try {
+    msg = parseHL7(Buffer.from(bytes));
+  } catch (e) {
+    return { ok: false, result: parseFailureResult("hl7", bytes, posture, e) };
+  }
+  const { bundle, issues } = toFhir(msg);
+  return {
+    ok: true,
+    conversion: {
+      bundleText: serializeResource(bundle),
+      findings: issues.map((i) => toFinding(i.code, i.severity, i.v2Location, i.fhirPath))
+    }
+  };
+}
+function toFinding(code, severity, v2Location, fhirPath) {
+  const location = fhirPath !== void 0 ? `${v2Location} \u2192 ${fhirPath}` : v2Location;
+  return { code, severity, location };
+}
+function convertOutcome(findings) {
+  const lines = findings.map((f) => `cosyte: convert: ${f.severity} ${f.code} at ${f.location}
+`);
+  const errors = findings.filter((f) => ERROR_SEVERITIES2.has(f.severity)).length;
+  const others = findings.length - errors;
+  const summary = errors > 0 ? `cosyte: convert: hl7 \u2192 fhir produced ${String(errors)} error(s), ${String(others)} other finding(s)
+` : `cosyte: convert: hl7 \u2192 fhir OK (${String(findings.length)} finding(s))
+`;
+  return { hasError: errors > 0, report: lines.join("") + summary };
+}
+var CONVERT_OPTIONS, SUPPORTED_TARGET, ERROR_SEVERITIES2;
+var init_convert = __esm({
+  "src/commands/convert.ts"() {
+    init_diagnostics();
+    init_exit_codes();
+    init_input();
+    init_phi();
+    init_wrap();
+    CONVERT_OPTIONS = {
+      to: { type: "string" },
+      format: { type: "string" },
+      json: { type: "boolean", default: false },
+      quiet: { type: "boolean", default: false },
+      "no-color": { type: "boolean", default: false }
+    };
+    SUPPORTED_TARGET = "fhir";
+    ERROR_SEVERITIES2 = /* @__PURE__ */ new Set(["error", "fatal"]);
+  }
+});
+async function inspectCommand(args, deps2, posture = VALUE_FREE) {
+  let values;
+  let positionals;
+  try {
+    const parsed = parseArgs({ args, options: INSPECT_OPTIONS, allowPositionals: true });
+    values = parsed.values;
+    positionals = parsed.positionals;
+  } catch {
+    return errorResult(
+      new CliError(
+        CLI_CODES.CLI_USAGE,
+        EXIT.USAGE,
+        "invalid arguments to `inspect` (see `cosyte inspect --help`)"
+      )
+    );
+  }
+  const resolved = await resolveInput(positionals[0], values.format, deps2, "inspect");
+  if (!resolved.ok) return resolved.result;
+  const { format, bytes } = resolved.input;
+  let summary;
+  try {
+    summary = await inspectFormat(format, bytes);
+  } catch (e) {
+    if (e instanceof CliError) return errorResult(e);
+    return parseFailureResult(format, bytes, posture, e);
+  }
+  const stdout = values.json === true ? `${JSON.stringify(summary)}
+` : renderSummary(summary);
+  return { stdout, stderr: "", exit: EXIT.OK };
+}
+function renderSummary(summary) {
+  const lines = [];
+  const countLines = (label, counts) => {
+    if (label.length > 0) lines.push(label);
+    for (const key of Object.keys(counts).sort()) lines.push(`  ${key}: ${String(counts[key])}`);
+  };
+  switch (summary.format) {
+    case "hl7":
+      lines.push(`format:       hl7`);
+      lines.push(`message type: ${summary.messageType ?? "(unknown)"}`);
+      lines.push(`version:      ${summary.version ?? "(unknown)"}`);
+      lines.push(`segments:     ${String(summary.segmentCount)}`);
+      countLines("", summary.segments);
+      lines.push(`warnings:     ${String(summary.warningCount)}`);
+      break;
+    case "fhir":
+      lines.push(`format:        fhir`);
+      lines.push(`resource type: ${summary.resourceType ?? "(unknown)"}`);
+      if (summary.entryCount !== void 0) {
+        lines.push(`bundle type:   ${summary.bundleType ?? "(unknown)"}`);
+        lines.push(`entries:       ${String(summary.entryCount)}`);
+        countLines("", summary.entryResourceTypes ?? {});
+      }
+      lines.push(`issues:        ${String(summary.issueCount)}`);
+      break;
+    case "x12":
+      lines.push(`format:       x12`);
+      lines.push(`groups:       ${String(summary.groupCount)}`);
+      lines.push(`transactions: ${String(summary.transactionCount)}`);
+      countLines("transaction sets:", summary.transactionSetIds);
+      lines.push(`segments:     ${String(summary.segmentCount)}`);
+      lines.push(`warnings:     ${String(summary.warningCount)}`);
+      break;
+    case "astm":
+      lines.push(`format:       astm`);
+      lines.push(`message kind: ${summary.messageKind}`);
+      lines.push(`records:      ${String(summary.recordCount)}`);
+      countLines("", summary.recordTypes);
+      lines.push(`warnings:     ${String(summary.warningCount)}`);
+      break;
+    case "ccda":
+      lines.push(`format:        ccda`);
+      lines.push(`document type: ${summary.documentType ?? "(unknown)"}`);
+      lines.push(`sections:      ${String(summary.sectionCount)}`);
+      if (summary.sectionCodes.length > 0) {
+        lines.push(`section codes: ${summary.sectionCodes.join(", ")}`);
+      }
+      lines.push(`warnings:      ${String(summary.warningCount)}`);
+      break;
+    case "dicom":
+      lines.push(`format:         dicom`);
+      lines.push(`sop class uid:  ${summary.sopClassUid ?? "(unknown)"}`);
+      lines.push(`transfer syntax:${summary.transferSyntaxUid ?? " (unknown)"}`);
+      lines.push(`elements:       ${String(summary.elementCount)}`);
+      lines.push(`warnings:       ${String(summary.warningCount)}`);
+      break;
+    case "ncpdp":
+      lines.push(`format:       ncpdp`);
+      lines.push(`standard:     SCRIPT`);
+      lines.push(`message type: ${summary.messageType ?? "(unknown)"}`);
+      lines.push(`version:      ${summary.version ?? "(unknown)"}`);
+      lines.push(`warnings:     ${String(summary.warningCount)}`);
+      break;
+    case "mllp":
+      lines.push(`format:  mllp`);
+      lines.push(`frames:  ${String(summary.frameCount)}`);
+      lines.push(`warnings:${String(summary.warningCount)}`);
+      break;
+  }
+  return lines.join("\n") + "\n";
+}
+var INSPECT_OPTIONS;
+var init_inspect = __esm({
+  "src/commands/inspect.ts"() {
+    init_diagnostics();
+    init_exit_codes();
+    init_input();
+    init_parsers();
+    init_phi();
+    init_wrap();
+    INSPECT_OPTIONS = {
+      format: { type: "string" },
+      json: { type: "boolean", default: false },
+      quiet: { type: "boolean", default: false },
+      "no-color": { type: "boolean", default: false }
+    };
+  }
+});
+async function parseCommand(args, deps2, posture = VALUE_FREE) {
+  let values;
+  let positionals;
+  try {
+    const parsed = parseArgs({ args, options: PARSE_OPTIONS, allowPositionals: true });
+    values = parsed.values;
+    positionals = parsed.positionals;
+  } catch {
+    return errorResult(
+      new CliError(
+        CLI_CODES.CLI_USAGE,
+        EXIT.USAGE,
+        "invalid arguments to `parse` (see `cosyte parse --help`)"
+      )
+    );
+  }
+  const resolved = await resolveInput(positionals[0], values.format, deps2, "parse");
+  if (!resolved.ok) return resolved.result;
+  const { format, bytes } = resolved.input;
+  if (format === "mllp" || values.ndjson === true) {
+    return await parseMulti(format, bytes, values.ndjson === true, values.quiet === true);
+  }
+  return await parseSingle(format, bytes, values.json === true, values.quiet === true, posture);
+}
+async function parseSingle(format, bytes, json, quiet, posture) {
+  let result;
+  try {
+    result = await parseFormat(format, bytes);
+  } catch (e) {
+    if (e instanceof CliError) return errorResult(e);
+    return parseFailureResult(format, bytes, posture, e);
+  }
+  const envelope = { format, model: result.model, warnings: result.warnings };
+  const stdout = (json ? JSON.stringify(envelope) : JSON.stringify(envelope, null, 2)) + "\n";
+  const n = envelope.warnings.length;
+  const stderr = n > 0 && !quiet ? `cosyte: parsed ${format} with ${String(n)} warning(s) (see .warnings in output)
+` : "";
+  return { stdout, stderr, exit: EXIT.OK };
+}
+async function parseMulti(format, bytes, ndjson, quiet) {
+  let records;
+  let recordFormat;
+  try {
+    if (format === "mllp") {
+      const { payloads } = await deframeMllp(bytes);
+      records = payloads;
+      recordFormat = "hl7";
+    } else {
+      records = splitLines(bytes);
+      recordFormat = format;
+    }
+  } catch (e) {
+    if (e instanceof CliError) return errorResult(e);
+    return parseFailureResult(format, bytes, VALUE_FREE, e);
+  }
+  if (records.length === 0) {
+    return errorResult(
+      new CliError(
+        CLI_CODES.CLI_PARSE_FAILED,
+        EXIT.DATAERR,
+        `no ${format === "mllp" ? "MLLP frame" : "record"} found in the input`
+      )
+    );
+  }
+  const lines = [];
+  let failed = 0;
+  let warnings = 0;
+  for (let i = 0; i < records.length; i += 1) {
+    const rec = records[i];
+    try {
+      const { model, warnings: ws } = await parseFormat(recordFormat, rec);
+      warnings += ws.length;
+      lines.push({ record: i, format: recordFormat, model, warnings: ws });
+    } catch (e) {
+      if (e instanceof CliError) return errorResult(e);
+      failed += 1;
+      lines.push({
+        record: i,
+        format: recordFormat,
+        error: extractStableCode(e) ?? "CLI_PARSE_FAILED"
+      });
+    }
+  }
+  const stdout = lines.map((l) => JSON.stringify(l)).join("\n") + "\n";
+  const exit = failed > 0 ? EXIT.DATAERR : EXIT.OK;
+  const stderr = quiet ? "" : `cosyte: parsed ${String(records.length)} ${recordFormat} record(s) (${String(warnings)} warning(s), ${String(failed)} failed)` + (ndjson ? " [ndjson]" : format === "mllp" ? " [mllp]" : "") + "\n";
+  return { stdout, stderr, exit };
+}
+function splitLines(bytes) {
+  const text = new TextDecoder("utf-8", { fatal: false }).decode(bytes);
+  const enc = new TextEncoder();
+  return text.split(/\r?\n/).filter((line) => line.trim().length > 0).map((line) => enc.encode(line));
+}
+var PARSE_OPTIONS;
+var init_parse = __esm({
+  "src/commands/parse.ts"() {
+    init_diagnostics();
+    init_exit_codes();
+    init_input();
+    init_parsers();
+    init_phi();
+    init_wrap();
+    PARSE_OPTIONS = {
+      format: { type: "string" },
+      ndjson: { type: "boolean", default: false },
+      json: { type: "boolean", default: false },
+      quiet: { type: "boolean", default: false },
+      "no-color": { type: "boolean", default: false }
+    };
+  }
+});
+async function validateCommand(args, deps2, posture = VALUE_FREE) {
+  let values;
+  let positionals;
+  try {
+    const parsed = parseArgs({ args, options: VALIDATE_OPTIONS, allowPositionals: true });
+    values = parsed.values;
+    positionals = parsed.positionals;
+  } catch {
+    return errorResult(
+      new CliError(
+        CLI_CODES.CLI_USAGE,
+        EXIT.USAGE,
+        "invalid arguments to `validate` (see `cosyte validate --help`)"
+      )
+    );
+  }
+  if (values.profile !== void 0) {
+    return errorResult(
+      new CliError(
+        CLI_CODES.CLI_NOT_IMPLEMENTED,
+        EXIT.UNAVAILABLE,
+        "profile-based validation is not yet available: the CLI bundles no profiles and cannot yet load one; validating against `--profile` is gated on that surface. Re-run without --profile for base validation."
+      )
+    );
+  }
+  const resolved = await resolveInput(positionals[0], values.format, deps2, "validate");
+  if (!resolved.ok) return resolved.result;
+  const { format, bytes } = resolved.input;
+  let verdict;
+  try {
+    verdict = await validateFormat(format, bytes);
+  } catch (e) {
+    if (e instanceof CliError) return errorResult(e);
+    return parseFailureResult(format, bytes, posture, e);
+  }
+  const exit = verdict.valid ? EXIT.OK : EXIT.INVALID;
+  if (values.json === true) {
+    const body = { format, valid: verdict.valid, findings: verdict.findings };
+    return { stdout: `${JSON.stringify(body)}
+`, stderr: "", exit };
+  }
+  if (values.quiet === true) {
+    return { stdout: "", stderr: "", exit };
+  }
+  return { stdout: "", stderr: renderReport(format, verdict), exit };
+}
+function renderReport(format, verdict) {
+  const lines = verdict.findings.map(
+    (f) => `cosyte: validate: ${f.severity} ${f.code} at ${f.location}
+`
+  );
+  const errors = verdict.findings.filter((f) => ERROR_SEVERITIES3.has(f.severity)).length;
+  const others = verdict.findings.length - errors;
+  const summary = verdict.valid ? `cosyte: validate: ${format} is valid (${String(verdict.findings.length)} finding(s))
+` : `cosyte: validate: ${format} is INVALID (${String(errors)} error(s), ${String(others)} other finding(s))
+`;
+  return lines.join("") + summary;
+}
+var VALIDATE_OPTIONS, ERROR_SEVERITIES3;
+var init_validate = __esm({
+  "src/commands/validate.ts"() {
+    init_diagnostics();
+    init_exit_codes();
+    init_input();
+    init_parsers();
+    init_phi();
+    init_wrap();
+    VALIDATE_OPTIONS = {
+      format: { type: "string" },
+      profile: { type: "string" },
+      json: { type: "boolean", default: false },
+      quiet: { type: "boolean", default: false },
+      "no-color": { type: "boolean", default: false }
+    };
+    ERROR_SEVERITIES3 = /* @__PURE__ */ new Set(["error", "fatal"]);
+  }
+});
+
+// src/core/version.ts
+var VERSION;
+var init_version = __esm({
+  "src/core/version.ts"() {
+    VERSION = "0.0.0";
+  }
+});
+
+// src/mcp/tools.ts
+function inlineDeps(content) {
+  const bytes = new TextEncoder().encode(content);
+  const noFile = new CliError(
+    CLI_CODES.CLI_NO_INPUT,
+    EXIT.NOINPUT,
+    "the MCP tools operate on inline content, not a file path"
+  );
+  return {
+    readStdin: () => Promise.resolve(bytes),
+    // The MCP tools always feed inline content via stdin (`-`); a file read is defensive and unreachable.
+    /* v8 ignore next -- unreachable: no MCP tool passes a file path, only inline `-` stdin content */
+    readFile: () => Promise.reject(noFile)
+  };
+}
+function stringArg(args, key) {
+  const v = args[key];
+  return typeof v === "string" ? v : null;
+}
+function toToolResult(result) {
+  const hardError = result.stdout === "";
+  const text = hardError ? result.stderr.trim() : result.stdout.trim();
+  return {
+    content: [
+      { type: "text", text: text.length > 0 ? text : `cosyte: exit ${String(result.exit)}` }
+    ],
+    isError: hardError,
+    structuredContent: { exit: result.exit, ok: !hardError }
+  };
+}
+function usageError(message) {
+  return {
+    content: [{ type: "text", text: `cosyte: ${CLI_CODES.CLI_USAGE}: ${message}` }],
+    isError: true,
+    structuredContent: { exit: EXIT.USAGE, ok: false }
+  };
+}
+function internalError(e) {
+  const err = toCliError(e);
+  return {
+    content: [{ type: "text", text: `cosyte: ${err.code}: ${err.message}` }],
+    isError: true,
+    structuredContent: { exit: err.exit, ok: false }
+  };
+}
+async function dispatchTool(name, args, deps2) {
+  const content = stringArg(args, "content");
+  if (content === null) {
+    return usageError("missing required 'content' argument (the message text to operate on)");
+  }
+  const runDeps = inlineDeps(content);
+  const format = stringArg(args, "format");
+  const fmtFlag = format !== null ? ["--format", format] : [];
+  try {
+    switch (name) {
+      case "parse":
+        return toToolResult(await parseCommand(["-", "--json", ...fmtFlag], runDeps, VALUE_FREE));
+      case "validate":
+        return toToolResult(
+          await validateCommand(["-", "--json", ...fmtFlag], runDeps, VALUE_FREE)
+        );
+      case "inspect":
+        return toToolResult(await inspectCommand(["-", "--json", ...fmtFlag], runDeps, VALUE_FREE));
+      case "convert": {
+        const to = stringArg(args, "to") ?? "fhir";
+        return toToolResult(await convertCommand(["-", "--to", to, "--json"], runDeps, VALUE_FREE));
+      }
+      default:
+        return usageError(`unknown tool '${name}'`);
+    }
+  } catch (e) {
+    return internalError(e);
+  }
+}
+var CONTENT_PROP, FORMAT_PROP, TOOL_DEFS;
+var init_tools = __esm({
+  "src/mcp/tools.ts"() {
+    init_convert();
+    init_inspect();
+    init_parse();
+    init_validate();
+    init_diagnostics();
+    init_exit_codes();
+    init_phi();
+    CONTENT_PROP = {
+      content: {
+        type: "string",
+        description: "The raw healthcare message to operate on (as text; e.g. an HL7 v2 message or a FHIR JSON resource)."
+      }
+    };
+    FORMAT_PROP = {
+      format: {
+        type: "string",
+        enum: ["hl7", "fhir", "dicom", "x12", "ccda", "ncpdp", "astm", "mllp"],
+        description: "Optional format override; omit to autodetect by content. A format whose parser does not support the requested operation returns a value-free CLI_FORMAT_UNSUPPORTED (never a fake)."
+      }
+    };
+    TOOL_DEFS = [
+      {
+        name: "parse",
+        description: "Parse a healthcare message (HL7 v2 or FHIR R4) to typed JSON. Format is autodetected by content. Returns the parsed model plus value-free warnings.",
+        inputSchema: {
+          type: "object",
+          properties: { ...CONTENT_PROP, ...FORMAT_PROP },
+          required: ["content"],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "validate",
+        description: "Validate a message and carry the verdict: ok=true with a valid result, or a result reporting value-free findings. The parsed-but-invalid verdict is a successful call (not a tool error).",
+        inputSchema: {
+          type: "object",
+          properties: { ...CONTENT_PROP, ...FORMAT_PROP },
+          required: ["content"],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "inspect",
+        description: "Return a value-free structural summary of a message: its type, segment/entry counts, and a warning/issue count. Never includes a field value.",
+        inputSchema: {
+          type: "object",
+          properties: { ...CONTENT_PROP, ...FORMAT_PROP },
+          required: ["content"],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "convert",
+        description: "Convert an HL7 v2 message to a FHIR R4 Bundle via @cosyte/transform. Returns the converted Bundle; an error-severity conversion issue is reported with ok=false.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            ...CONTENT_PROP,
+            to: {
+              type: "string",
+              enum: ["fhir"],
+              description: "The conversion target (only FHIR R4 is supported today)."
+            }
+          },
+          required: ["content"],
+          additionalProperties: false
+        }
+      }
+    ];
+  }
+});
+
+// src/mcp/server.ts
+var server_exports = {};
+__export(server_exports, {
+  SERVER_INFO: () => SERVER_INFO,
+  createMcpServer: () => createMcpServer,
+  startStdioServer: () => startStdioServer
+});
+function createMcpServer() {
+  const server = new Server(SERVER_INFO, { capabilities: { tools: {} } });
+  server.setRequestHandler(ListToolsRequestSchema, () => ({
+    tools: TOOL_DEFS.map((t) => ({
+      name: t.name,
+      description: t.description,
+      inputSchema: {
+        type: t.inputSchema.type,
+        properties: { ...t.inputSchema.properties },
+        ...t.inputSchema.required !== void 0 ? { required: [...t.inputSchema.required] } : {},
+        ...t.inputSchema.additionalProperties !== void 0 ? { additionalProperties: t.inputSchema.additionalProperties } : {}
+      }
+    }))
+  }));
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    const result = await dispatchTool(name, args ?? {});
+    return {
+      content: result.content.map((c) => ({ type: c.type, text: c.text })),
+      isError: result.isError,
+      structuredContent: { exit: result.structuredContent.exit, ok: result.structuredContent.ok }
+    };
+  });
+  return server;
+}
+async function startStdioServer() {
+  const server = createMcpServer();
+  await server.connect(new StdioServerTransport());
+}
+var SERVER_INFO;
+var init_server = __esm({
+  "src/mcp/server.ts"() {
+    init_version();
+    init_tools();
+    SERVER_INFO = { name: "cosyte", version: VERSION };
+  }
+});
+
+// src/core/io.ts
+init_diagnostics();
+init_exit_codes();
+async function readFileBytes(path) {
+  try {
+    return await readFile(path);
+  } catch {
+    throw new CliError(
+      CLI_CODES.CLI_NO_INPUT,
+      EXIT.NOINPUT,
+      `cannot read input file: ${path} (does it exist and is it readable?)`
+    );
+  }
+}
+async function readStreamBytes(stream) {
+  const chunks = [];
+  for await (const chunk of stream) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk, "utf-8") : chunk);
+  }
+  return Buffer.concat(chunks);
+}
+
+// src/commands/completion.ts
+init_diagnostics();
+init_exit_codes();
+var COMMANDS = [
+  "parse",
+  "validate",
+  "inspect",
+  "fmt",
+  "convert",
+  "map-codes",
+  "redact",
+  "deid",
+  "mcp",
+  "completion"
+];
+var FLAGS = [
+  "--format",
+  "--json",
+  "--ndjson",
+  "--quiet",
+  "--no-color",
+  "--unsafe-show-values",
+  "--help",
+  "--version"
+];
+var SHELLS = ["bash", "zsh", "fish"];
+function completionCommand(args) {
+  const shell = args[0];
+  if (shell === void 0) {
+    return errorResult(
+      new CliError(
+        CLI_CODES.CLI_USAGE,
+        EXIT.USAGE,
+        `missing shell; usage: cosyte completion <${SHELLS.join("|")}>`
+      )
+    );
+  }
+  if (!isShell(shell)) {
+    return errorResult(
+      new CliError(
+        CLI_CODES.CLI_USAGE,
+        EXIT.USAGE,
+        `unknown shell '${shell}'; supported: ${SHELLS.join(", ")}`
+      )
+    );
+  }
+  return { stdout: SCRIPTS[shell](), stderr: "", exit: EXIT.OK };
+}
+function isShell(value) {
+  return SHELLS.includes(value);
+}
+var SCRIPTS = {
+  bash: () => `# cosyte bash completion: source <(cosyte completion bash)
+_cosyte() {
+  local cur prev cmds flags
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  cmds="${COMMANDS.join(" ")}"
+  flags="${FLAGS.join(" ")}"
+  if [ "\${COMP_CWORD}" -eq 1 ]; then
+    COMPREPLY=( $(compgen -W "\${cmds}" -- "\${cur}") )
+  else
+    COMPREPLY=( $(compgen -W "\${flags}" -f -- "\${cur}") )
+  fi
+}
+complete -F _cosyte cosyte
+`,
+  zsh: () => `#compdef cosyte
+# cosyte zsh completion: source <(cosyte completion zsh)
+_cosyte() {
+  local -a cmds flags
+  cmds=(${COMMANDS.map((c) => `'${c}'`).join(" ")})
+  flags=(${FLAGS.map((f) => `'${f}'`).join(" ")})
+  if (( CURRENT == 2 )); then
+    _describe 'command' cmds
+  else
+    _describe 'flag' flags
+    _files
+  fi
+}
+compdef _cosyte cosyte
+`,
+  fish: () => {
+    const lines = COMMANDS.map(
+      (c) => `complete -c cosyte -n '__fish_use_subcommand' -a '${c}' -d 'cosyte ${c}'`
+    );
+    const flagLines = FLAGS.filter((f) => f.startsWith("--")).map(
+      (f) => `complete -c cosyte -l '${f.slice(2)}'`
+    );
+    return `# cosyte fish completion: cosyte completion fish | source
+${lines.join("\n")}
+${flagLines.join("\n")}
+`;
+  }
+};
+
+// src/core/run.ts
+init_convert();
+
+// src/commands/fmt.ts
+init_diagnostics();
+init_exit_codes();
+init_input();
+init_parsers();
+init_phi();
+init_wrap();
+var FMT_OPTIONS = {
+  format: { type: "string" },
+  quiet: { type: "boolean", default: false },
+  "no-color": { type: "boolean", default: false }
+};
+async function fmtCommand(args, deps2, posture = VALUE_FREE) {
+  let values;
+  let positionals;
+  try {
+    const parsed = parseArgs({ args, options: FMT_OPTIONS, allowPositionals: true });
+    values = parsed.values;
+    positionals = parsed.positionals;
+  } catch {
+    return errorResult(
+      new CliError(
+        CLI_CODES.CLI_USAGE,
+        EXIT.USAGE,
+        "invalid arguments to `fmt` (see `cosyte fmt --help`)"
+      )
+    );
+  }
+  const resolved = await resolveInput(positionals[0], values.format, deps2, "fmt");
+  if (!resolved.ok) return resolved.result;
+  const { format, bytes } = resolved.input;
+  let result;
+  try {
+    result = await fmtFormat(format, bytes);
+  } catch (e) {
+    if (e instanceof CliError) return errorResult(e);
+    return parseFailureResult(format, bytes, posture, e);
+  }
+  const stderr = result.warningCount > 0 && values.quiet !== true ? `cosyte: fmt: re-serialized ${format} with ${String(result.warningCount)} parse warning(s)
+` : "";
+  return { stdout: `${result.output}
+`, stderr, exit: EXIT.OK };
+}
+
+// src/core/run.ts
+init_inspect();
+
+// src/commands/map-codes.ts
+init_diagnostics();
+init_exit_codes();
+init_wrap();
+var MAP_CODES_OPTIONS = {
+  code: { type: "string" },
+  system: { type: "string" },
+  version: { type: "string" },
+  display: { type: "string" },
+  json: { type: "boolean", default: false },
+  quiet: { type: "boolean", default: false },
+  "no-color": { type: "boolean", default: false }
+};
+async function mapCodesCommand(args, deps2) {
+  let values;
+  let positionals;
+  try {
+    const parsed = parseArgs({ args, options: MAP_CODES_OPTIONS, allowPositionals: true });
+    values = parsed.values;
+    positionals = parsed.positionals;
+  } catch {
+    return errorResult(
+      new CliError(
+        CLI_CODES.CLI_USAGE,
+        EXIT.USAGE,
+        "invalid arguments to `map-codes` (see `cosyte map-codes --help`)"
+      )
+    );
+  }
+  const source = positionals[0];
+  if (source === void 0) {
+    return errorResult(
+      new CliError(
+        CLI_CODES.CLI_USAGE,
+        EXIT.USAGE,
+        "missing <conceptmap> argument; pass a FHIR ConceptMap path or `-` to read stdin"
+      )
+    );
+  }
+  if (values.code === void 0) {
+    return errorResult(
+      new CliError(
+        CLI_CODES.CLI_USAGE,
+        EXIT.USAGE,
+        "map-codes requires --code (the source code to translate)"
+      )
+    );
+  }
+  let bytes;
+  try {
+    bytes = source === "-" ? await deps2.readStdin() : await deps2.readFile(source);
+  } catch (e) {
+    if (e instanceof CliError) return errorResult(e);
+    throw e;
+  }
+  if (bytes.length === 0) {
+    return errorResult(new CliError(CLI_CODES.CLI_EMPTY_INPUT, EXIT.DATAERR, "input is empty"));
+  }
+  const coding = {
+    code: values.code,
+    ...values.system !== void 0 ? { system: values.system } : {},
+    ...values.version !== void 0 ? { version: values.version } : {},
+    ...values.display !== void 0 ? { display: values.display } : {}
+  };
+  const outcome = await translateVia(bytes, coding);
+  if (!outcome.ok) return outcome.result;
+  const { result } = outcome;
+  const exit = result.unmapped ? EXIT.INVALID : EXIT.OK;
+  const body = { source: coding, result };
+  if (values.json === true) {
+    return { stdout: `${JSON.stringify(body)}
+`, stderr: "", exit };
+  }
+  const stderr = values.quiet === true ? "" : renderNote(result);
+  return { stdout: `${JSON.stringify(body, null, 2)}
+`, stderr, exit };
+}
+async function translateVia(bytes, coding) {
+  const text = new TextDecoder("utf-8", { fatal: false }).decode(bytes);
+  let json;
+  try {
+    json = JSON.parse(text);
+  } catch {
+    return mapInvalid("the ConceptMap input is not valid JSON");
+  }
+  const { loadConceptMap, translate } = await import('@cosyte/terminology');
+  let map;
+  try {
+    map = loadConceptMap(json);
+  } catch (e) {
+    const code = extractStableCode(e);
+    const detail = code === null ? "" : ` (${code})`;
+    return mapInvalid(`the supplied ConceptMap could not be loaded${detail}`);
+  }
+  return { ok: true, result: translate(coding, map) };
+}
+function mapInvalid(message) {
+  return {
+    ok: false,
+    result: errorResult(new CliError(CLI_CODES.CLI_MAP_INVALID, EXIT.DATAERR, message))
+  };
+}
+function renderNote(result) {
+  if (result.unmapped) {
+    return `cosyte: map-codes: ${result.code} (fallback mode: ${result.mode})
+`;
+  }
+  return `cosyte: map-codes: ${String(result.matches.length)} match(es)
+`;
+}
+
+// src/core/run.ts
+init_parse();
+
+// src/commands/redact.ts
+init_diagnostics();
+
+// src/core/deid.ts
+var DEID_UNAVAILABLE_REASON = "redact/deid is not yet available. It delegates to @cosyte/deid, which is unpublished. The CLI ships no built-in redactor: a partial Safe-Harbor scrub over only the obvious PHI loci would leave PHI behind and present a false-safety impression, so nothing is emitted. This command will produce a de-identified copy once @cosyte/deid ships and is vetted.";
+function deidStatus() {
+  return { available: false, reason: DEID_UNAVAILABLE_REASON };
+}
+
+// src/commands/redact.ts
+init_exit_codes();
+var REDACT_OPTIONS = {
+  format: { type: "string" }
+};
+function redactCommand(args) {
+  try {
+    parseArgs({ args, options: REDACT_OPTIONS, allowPositionals: true });
+  } catch {
+    return {
+      stdout: "",
+      stderr: `cosyte: ${CLI_CODES.CLI_USAGE}: invalid arguments to \`redact\` (see \`cosyte --help\`)
+`,
+      exit: EXIT.USAGE
+    };
+  }
+  const status = deidStatus();
+  return {
+    stdout: "",
+    stderr: `cosyte: ${CLI_CODES.CLI_NOT_IMPLEMENTED}: ${status.reason}
+`,
+    exit: EXIT.UNAVAILABLE
+  };
+}
+
+// src/core/run.ts
+init_validate();
+init_diagnostics();
+init_exit_codes();
+init_phi();
+init_version();
+var HELP = `cosyte: a PHI-safe developer CLI over the @cosyte/* healthcare parsers
+
+Usage:
+  cosyte <command> [options]
+
+Commands:
+  parse <file|->      Parse a healthcare message to typed JSON (format autodetected)
+  validate <file|->   Validate a message; exit code carries the verdict (0 valid / 1 invalid)
+  inspect <file|->    Print a value-free structural summary (segment/resource counts, type)
+  fmt <file|->        Canonically re-serialize via the parser's spec-clean serializer
+  convert <file|->    Convert HL7 v2 \u2192 FHIR R4 via @cosyte/transform (use --to fhir)
+  map-codes <cmap|->  Translate a code through a BYO FHIR ConceptMap via @cosyte/terminology
+  redact <file|->     De-identify a message (alias: deid): gated on @cosyte/deid, not yet available
+  mcp                 Start the stdio MCP server (agent front door; also the cosyte-mcp bin)
+  completion <shell>  Print a shell completion script (bash | zsh | fish)
+
+Global:
+  -h, --help              Show this help
+  -V, --version           Show the CLI version
+  --unsafe-show-values    Permit input values on stderr/diagnostics (PHI-exposing; off by default)
+
+Common options (parse / validate / inspect / fmt):
+  --format <fmt>    Override autodetection: hl7 | fhir | dicom | x12 | ccda | ncpdp | astm | mllp
+                    (parse: hl7 fhir x12 astm ncpdp mllp \xB7 inspect: all \xB7 fmt: hl7 fhir x12 astm
+                     ccda ncpdp \xB7 validate: all but mllp; dicom/ccda parse & mllp fmt are deferred)
+  --json            Machine-readable JSON output (parse / validate / inspect / convert / map-codes)
+  --ndjson          Treat each non-empty input line as a record; emit NDJSON (parse; FHIR bulk data)
+  --quiet           Suppress value-free notes on stderr
+  --no-color        Disable ANSI colour
+
+convert options:
+  --to fhir         The conversion target (required; only HL7 v2 \u2192 FHIR R4 today)
+
+map-codes options (the positional is a BYO FHIR ConceptMap; a code is not PHI):
+  --code <code>     The source code to translate (required)
+  --system <uri>    The source code system (optional; selects the ConceptMap group)
+  --version <v>     The source code system version (optional)
+  --display <d>     The source display (optional)
+
+Exit codes:
+  0   success / valid    65  data error (unparseable / undetected format)
+  1   invalid (validate) 66  no input (missing/unreadable file)
+  2   usage error        69  unavailable (a capability is not yet built, e.g. redact)
+                         70  internal error
+
+PHI posture: the parsed model goes to stdout (the data channel you chose); every diagnostic on
+stderr is value-free (codes and positions only, never a field value) unless you pass the loud,
+opt-in --unsafe-show-values (which permits a bounded input excerpt in a failure diagnostic).
+`;
+function wantsHelp(argv) {
+  return argv.includes("--help") || argv.includes("-h");
+}
+async function run(argv, deps2) {
+  const { posture, argv: rest0 } = extractPhiPosture(argv);
+  const [command, ...rest] = rest0;
+  if (command === void 0 || wantsHelp(rest0)) {
+    return { stdout: HELP, stderr: "", exit: EXIT.OK };
+  }
+  if (command === "--version" || command === "-V") {
+    return { stdout: `${VERSION}
+`, stderr: "", exit: EXIT.OK };
+  }
+  try {
+    switch (command) {
+      case "parse":
+        return await parseCommand(rest, deps2, posture);
+      case "validate":
+        return await validateCommand(rest, deps2, posture);
+      case "inspect":
+        return await inspectCommand(rest, deps2, posture);
+      case "fmt":
+        return await fmtCommand(rest, deps2, posture);
+      case "convert":
+        return await convertCommand(rest, deps2, posture);
+      case "map-codes":
+        return await mapCodesCommand(rest, deps2);
+      case "redact":
+      case "deid":
+        return redactCommand(rest);
+      case "completion":
+        return completionCommand(rest);
+      default:
+        return resolve(
+          new CliError(
+            CLI_CODES.CLI_USAGE,
+            EXIT.USAGE,
+            `unknown command '${command}'; run \`cosyte --help\``
+          )
+        );
+    }
+  } catch (e) {
+    return resolve(toCliError(e));
+  }
+}
+function resolve(e) {
+  return { stdout: "", stderr: `cosyte: ${e.code}: ${e.message}
+`, exit: e.exit };
+}
+
+// src/bin/cosyte.ts
+var deps = {
+  readFile: (path) => readFileBytes(path),
+  readStdin: () => readStreamBytes(process.stdin)
+};
+if (process.argv[2] === "mcp") {
+  Promise.resolve().then(() => (init_server(), server_exports)).then(({ startStdioServer: startStdioServer2 }) => startStdioServer2()).catch(() => {
+    process.stderr.write("cosyte: CLI_INTERNAL: the MCP server failed to start\n");
+    process.exitCode = 70;
+  });
+} else {
+  run(process.argv.slice(2), deps).then((result) => {
+    if (result.stdout) process.stdout.write(result.stdout);
+    if (result.stderr) process.stderr.write(result.stderr);
+    process.exitCode = result.exit;
+  }).catch(() => {
+    process.stderr.write("cosyte: CLI_INTERNAL: an unexpected internal error occurred\n");
+    process.exitCode = 70;
+  });
+}
+//# sourceMappingURL=cosyte.mjs.map
+//# sourceMappingURL=cosyte.mjs.map