ezmedicationinput 0.1.34 → 0.1.35

package/README.md

@@ -5,6 +5,7 @@
 ## Features
 
 - Converts shorthand strings (e.g. `1x3 po pc`, `500 mg po q6h prn pain`) into FHIR-compliant dosage JSON.
+- Parses multi-clause sigs into multiple dosage items (e.g. `OD ... , OS ...`) while preserving a first-item compatibility shape for legacy single-dose consumers.
 - Emits timing abbreviations (`timing.code`) and repeat structures simultaneously where possible.
 - Maps meal/time blocks to the correct `Timing.repeat.when` **EventTiming** codes and can auto-expand AC/PC/C into specific meals.
 - Outputs SNOMED CT route codings (while providing friendly text) and round-trips known SNOMED routes back into the parser.
@@ -28,29 +29,57 @@ npm install ezmedicationinput
 ```ts
 import { parseSig } from "ezmedicationinput";
 
-const result = parseSig("1x3 po pc", { context: { dosageForm: "tab" } });
-console.log(result.fhir);
+const batch = parseSig("1x3 po pc", { context: { dosageForm: "tab" } });
+
+// New API
+console.log(batch.count);      // 1
+console.log(batch.items[0].fhir);
+
+// Legacy compatibility (first parsed item)
+console.log(batch.fhir);
 ```
 
 Example output:
 
 ```json
 {
-  "text": "1 tablet by mouth three times daily after meals",
-  "timing": {
-    "code": { "coding": [{ "code": "TID" }], "text": "TID" },
-    "repeat": {
-      "frequency": 3,
-      "period": 1,
-      "periodUnit": "d",
-      "when": ["PC"]
+  "count": 1,
+  "items": [
+    {
+      "fhir": {
+        "text": "Take 1 tablet by mouth three times daily after meals.",
+        "timing": {
+          "code": { "coding": [{ "code": "TID" }], "text": "TID" },
+          "repeat": {
+            "frequency": 3,
+            "period": 1,
+            "periodUnit": "d",
+            "when": ["PC"]
+          }
+        },
+        "route": { "text": "by mouth" },
+        "doseAndRate": [{ "doseQuantity": { "value": 1, "unit": "tab" } }]
+      }
     }
-  },
-  "route": { "text": "by mouth" },
-  "doseAndRate": [{ "doseQuantity": { "value": 1, "unit": "tab" } }]
+  ],
+  "fhir": { "...": "same as items[0].fhir for compatibility" }
 }
 ```
 
+### Multi-clause parsing and legacy compatibility
+
+`parseSig` / `parseSigAsync` return a **batch** object:
+
+- `count`: number of parsed dosage clauses
+- `items`: array of full parse results (one per clause)
+- `meta.segments`: source ranges for each clause
+
+For single-dose integrations that haven't migrated yet, the batch also keeps legacy first-item fields:
+
+- `fhir`, `shortText`, `longText`, `warnings`, `meta`, and for linting `result`/`issues`
+
+So existing code that expects one result can continue using first-item compatibility while newer code uses `items[]`.
+
 ### PRN reasons & additional instructions
 
 `parseSig` identifies PRN (as-needed) clauses and trailing instructions, then
@@ -101,9 +130,28 @@ rendering.
 
 When a PRN reason cannot be auto-resolved, any registered suggestion resolvers
 are invoked and their responses are surfaced through
-`ParseResult.meta.prnReasonLookups` so client applications can prompt the user
+`ParseBatchResult.items[n].meta.prnReasonLookups` so client applications can prompt the user
 to choose a coded concept.
 
+### Formatting multi-item results back to sig text
+
+Use either helper depending on your source:
+
+- `formatParseBatch(batch, style?, separator?)` when you already have `parseSig` output.
+- `formatSigBatch(dosages, style?, { separator })` when you have an array of FHIR `Dosage` entries.
+
+```ts
+import { formatParseBatch, formatSigBatch, parseSig } from "ezmedicationinput";
+
+const batch = parseSig("1 tab po @ 8:00, 2 tabs po with lunch, 1 tab before dinner, 4 tabs po hs");
+
+const shortSig = formatParseBatch(batch, "short");
+// => "1 tab PO 08:00, 2 tab PO CD, 1 tab PO ACV, 4 tab PO HS"
+
+const shortFromFhir = formatSigBatch(batch.items.map((item) => item.fhir), "short");
+// => same combined short sig text
+```
+
 ### Sig (directions) suggestions
 
 Use `suggestSig` to drive autocomplete experiences while the clinician is

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { FhirDosage, FormatOptions, LintResult, ParseOptions, ParseResult } from "./types";
+import { FhirDosage, FormatBatchOptions, FormatOptions, LintBatchResult, ParseBatchResult, ParseOptions, ParseResult } from "./types";
 export { parseInternal } from "./parser";
 export { suggestSig } from "./suggest";
 export * from "./types";
@@ -7,8 +7,10 @@ export { parseStrength, parseStrengthIntoRatio } from "./utils/strength";
 export { getRegisteredSigLocalizations, registerSigLocalization, resolveSigLocalization, resolveSigTranslation } from "./i18n";
 export type { SigLocalization, SigLocalizationConfig, SigTranslation, SigTranslationConfig } from "./i18n";
 export { DEFAULT_BODY_SITE_SNOMED, DEFAULT_BODY_SITE_SNOMED_SOURCE, DEFAULT_ROUTE_SYNONYMS, DEFAULT_UNIT_BY_ROUTE, KNOWN_DOSAGE_FORMS_TO_DOSE } from './maps';
-export declare function parseSig(input: string, options?: ParseOptions): ParseResult;
-export declare function lintSig(input: string, options?: ParseOptions): LintResult;
-export declare function parseSigAsync(input: string, options?: ParseOptions): Promise<ParseResult>;
+export declare function parseSig(input: string, options?: ParseOptions): ParseBatchResult;
+export declare function lintSig(input: string, options?: ParseOptions): LintBatchResult;
+export declare function parseSigAsync(input: string, options?: ParseOptions): Promise<ParseBatchResult>;
 export declare function formatSig(dosage: FhirDosage, style?: "short" | "long", options?: FormatOptions): string;
+export declare function formatSigBatch(dosages: FhirDosage[], style?: "short" | "long", options?: FormatBatchOptions): string;
+export declare function formatParseBatch(batch: ParseBatchResult, style?: "short" | "long", separator?: string): string;
 export declare function fromFhirDosage(dosage: FhirDosage, options?: FormatOptions): ParseResult;

package/dist/index.js

@@ -28,11 +28,14 @@ exports.parseSig = parseSig;
 exports.lintSig = lintSig;
 exports.parseSigAsync = parseSigAsync;
 exports.formatSig = formatSig;
+exports.formatSigBatch = formatSigBatch;
+exports.formatParseBatch = formatParseBatch;
 exports.fromFhirDosage = fromFhirDosage;
 const format_1 = require("./format");
 const fhir_1 = require("./fhir");
 const i18n_1 = require("./i18n");
 const parser_1 = require("./parser");
+const segment_1 = require("./segment");
 var parser_2 = require("./parser");
 Object.defineProperty(exports, "parseInternal", { enumerable: true, get: function () { return parser_2.parseInternal; } });
 var suggest_1 = require("./suggest");
@@ -55,37 +58,104 @@ Object.defineProperty(exports, "DEFAULT_BODY_SITE_SNOMED_SOURCE", { enumerable:
 Object.defineProperty(exports, "DEFAULT_ROUTE_SYNONYMS", { enumerable: true, get: function () { return maps_1.DEFAULT_ROUTE_SYNONYMS; } });
 Object.defineProperty(exports, "DEFAULT_UNIT_BY_ROUTE", { enumerable: true, get: function () { return maps_1.DEFAULT_UNIT_BY_ROUTE; } });
 Object.defineProperty(exports, "KNOWN_DOSAGE_FORMS_TO_DOSE", { enumerable: true, get: function () { return maps_1.KNOWN_DOSAGE_FORMS_TO_DOSE; } });
+function toSegmentMeta(segments) {
+    return segments.map((segment, index) => ({
+        index,
+        text: segment.text,
+        range: { start: segment.start, end: segment.end }
+    }));
+}
 function parseSig(input, options) {
-    const internal = (0, parser_1.parseInternal)(input, options);
-    (0, parser_1.applyPrnReasonCoding)(internal, options);
-    (0, parser_1.applySiteCoding)(internal, options);
-    return buildParseResult(internal, options);
+    const segments = (0, segment_1.splitSigSegments)(input);
+    const carry = {};
+    const results = [];
+    for (const segment of segments) {
+        const internal = (0, parser_1.parseInternal)(segment.text, options);
+        applyCarryForward(internal, carry);
+        (0, parser_1.applyPrnReasonCoding)(internal, options);
+        (0, parser_1.applySiteCoding)(internal, options);
+        const result = buildParseResult(internal, options);
+        rebaseParseResult(result, input, segment.start);
+        results.push(result);
+        updateCarryForward(carry, internal);
+    }
+    const legacy = resolveLegacyParseResult(results, input, options);
+    return {
+        input,
+        count: results.length,
+        items: results,
+        fhir: legacy.fhir,
+        shortText: legacy.shortText,
+        longText: legacy.longText,
+        warnings: legacy.warnings,
+        meta: Object.assign(Object.assign({}, legacy.meta), { segments: toSegmentMeta(segments) })
+    };
 }
 function lintSig(input, options) {
-    const internal = (0, parser_1.parseInternal)(input, options);
-    (0, parser_1.applyPrnReasonCoding)(internal, options);
-    (0, parser_1.applySiteCoding)(internal, options);
-    const result = buildParseResult(internal, options);
-    const groups = (0, parser_1.findUnparsedTokenGroups)(internal);
-    const issues = groups.map((group) => {
-        const text = group.range
-            ? internal.input.slice(group.range.start, group.range.end)
-            : group.tokens.map((token) => token.original).join(" ");
-        return {
-            message: "Unrecognized text",
-            text: text.trim() || text,
-            tokens: group.tokens.map((token) => token.original),
-            range: group.range
-        };
-    });
-    return { result, issues };
+    const segments = (0, segment_1.splitSigSegments)(input);
+    const carry = {};
+    const results = [];
+    for (const segment of segments) {
+        const internal = (0, parser_1.parseInternal)(segment.text, options);
+        applyCarryForward(internal, carry);
+        (0, parser_1.applyPrnReasonCoding)(internal, options);
+        (0, parser_1.applySiteCoding)(internal, options);
+        const result = buildParseResult(internal, options);
+        rebaseParseResult(result, input, segment.start);
+        const groups = (0, parser_1.findUnparsedTokenGroups)(internal);
+        const issues = groups.map((group) => {
+            const shiftedRange = shiftRange(group.range, segment.start);
+            const text = shiftedRange
+                ? input.slice(shiftedRange.start, shiftedRange.end)
+                : group.tokens.map((token) => token.original).join(" ");
+            return {
+                message: "Unrecognized text",
+                text: text.trim() || text,
+                tokens: group.tokens.map((token) => token.original),
+                range: shiftedRange
+            };
+        });
+        results.push({ result, issues });
+        updateCarryForward(carry, internal);
+    }
+    const legacy = resolveLegacyLintResult(results, input, options);
+    return {
+        input,
+        count: results.length,
+        items: results,
+        result: legacy.result,
+        issues: legacy.issues,
+        meta: {
+            segments: toSegmentMeta(segments)
+        }
+    };
 }
 function parseSigAsync(input, options) {
     return __awaiter(this, void 0, void 0, function* () {
-        const internal = (0, parser_1.parseInternal)(input, options);
-        yield (0, parser_1.applyPrnReasonCodingAsync)(internal, options);
-        yield (0, parser_1.applySiteCodingAsync)(internal, options);
-        return buildParseResult(internal, options);
+        const segments = (0, segment_1.splitSigSegments)(input);
+        const carry = {};
+        const results = [];
+        for (const segment of segments) {
+            const internal = (0, parser_1.parseInternal)(segment.text, options);
+            applyCarryForward(internal, carry);
+            yield (0, parser_1.applyPrnReasonCodingAsync)(internal, options);
+            yield (0, parser_1.applySiteCodingAsync)(internal, options);
+            const result = buildParseResult(internal, options);
+            rebaseParseResult(result, input, segment.start);
+            results.push(result);
+            updateCarryForward(carry, internal);
+        }
+        const legacy = resolveLegacyParseResult(results, input, options);
+        return {
+            input,
+            count: results.length,
+            items: results,
+            fhir: legacy.fhir,
+            shortText: legacy.shortText,
+            longText: legacy.longText,
+            warnings: legacy.warnings,
+            meta: Object.assign(Object.assign({}, legacy.meta), { segments: toSegmentMeta(segments) })
+        };
     });
 }
 function formatSig(dosage, style = "short", options) {
@@ -93,6 +163,24 @@ function formatSig(dosage, style = "short", options) {
     const localization = (0, i18n_1.resolveSigLocalization)(options === null || options === void 0 ? void 0 : options.locale, options === null || options === void 0 ? void 0 : options.i18n);
     return (0, format_1.formatInternal)(internal, style, localization);
 }
+function formatSigBatch(dosages, style = "short", options) {
+    var _a;
+    const separator = (_a = options === null || options === void 0 ? void 0 : options.separator) !== null && _a !== void 0 ? _a : ", ";
+    const formatted = [];
+    for (const dosage of dosages) {
+        const text = formatSig(dosage, style, options);
+        if (text.trim()) {
+            formatted.push(text);
+        }
+    }
+    return formatted.join(separator);
+}
+function formatParseBatch(batch, style = "short", separator = ", ") {
+    const texts = batch.items
+        .map((item) => (style === "short" ? item.shortText : item.longText))
+        .filter((text) => typeof text === "string" && text.trim().length > 0);
+    return texts.join(separator);
+}
 function fromFhirDosage(dosage, options) {
     var _a, _b, _c, _d, _e, _f;
     const internal = (0, fhir_1.internalFromFhir)(dosage);
@@ -255,3 +343,98 @@ function buildParseResult(internal, options) {
         }
     };
 }
+function applyCarryForward(internal, carry) {
+    if (!internal.routeCode && !internal.routeText) {
+        if (carry.routeCode) {
+            internal.routeCode = carry.routeCode;
+        }
+        if (!internal.routeText && carry.routeText) {
+            internal.routeText = carry.routeText;
+        }
+    }
+    if (!internal.unit && carry.unit) {
+        internal.unit = carry.unit;
+    }
+    if (internal.dose === undefined &&
+        internal.doseRange === undefined &&
+        carry.dose !== undefined &&
+        internal.unit &&
+        internal.unit === carry.unit) {
+        internal.dose = carry.dose;
+    }
+}
+function updateCarryForward(carry, internal) {
+    if (internal.routeCode) {
+        carry.routeCode = internal.routeCode;
+    }
+    if (internal.routeText) {
+        carry.routeText = internal.routeText;
+    }
+    if (internal.unit) {
+        carry.unit = internal.unit;
+    }
+    if (internal.dose !== undefined) {
+        carry.dose = internal.dose;
+    }
+}
+function rebaseParseResult(result, fullInput, offset) {
+    const rebaseRequest = (request) => {
+        request.inputText = fullInput;
+        if (request.range) {
+            request.range = shiftRange(request.range, offset);
+            if (request.range) {
+                request.sourceText = fullInput.slice(request.range.start, request.range.end);
+            }
+        }
+    };
+    if (result.meta.siteLookups) {
+        for (const lookup of result.meta.siteLookups) {
+            rebaseRequest(lookup.request);
+        }
+    }
+    if (result.meta.prnReasonLookups) {
+        for (const lookup of result.meta.prnReasonLookups) {
+            rebaseRequest(lookup.request);
+        }
+    }
+}
+function shiftRange(range, offset) {
+    if (!range) {
+        return undefined;
+    }
+    return {
+        start: range.start + offset,
+        end: range.end + offset
+    };
+}
+function resolveLegacyParseResult(results, input, options) {
+    if (results.length > 0) {
+        return results[0];
+    }
+    const internal = (0, parser_1.parseInternal)(input, options);
+    (0, parser_1.applyPrnReasonCoding)(internal, options);
+    (0, parser_1.applySiteCoding)(internal, options);
+    return buildParseResult(internal, options);
+}
+function resolveLegacyLintResult(results, input, options) {
+    if (results.length > 0) {
+        return results[0];
+    }
+    const internal = (0, parser_1.parseInternal)(input, options);
+    (0, parser_1.applyPrnReasonCoding)(internal, options);
+    (0, parser_1.applySiteCoding)(internal, options);
+    const result = buildParseResult(internal, options);
+    const groups = (0, parser_1.findUnparsedTokenGroups)(internal);
+    const issues = groups.map((group) => {
+        const text = group.range
+            ? internal.input.slice(group.range.start, group.range.end)
+            : group.tokens.map((token) => token.original).join(" ");
+        return {
+            message: "Unrecognized text",
+            text: text.trim() || text,
+            tokens: group.tokens.map((token) => token.original),
+            range: group.range
+        };
+    });
+    return { result, issues };
+}

package/dist/parser.js

@@ -1870,6 +1870,9 @@ function parseInternal(input, options) {
                 : maps_1.DEFAULT_ROUTE_SYNONYMS[phrase];
             if (synonym) {
                 if (phrase === "in" && slice.length === 1) {
+                    if (internal.routeCode) {
+                        continue;
+                    }
                     const prevToken = tokens[startIndex - 1];
                     if (prevToken && !internal.consumed.has(prevToken.index)) {
                         continue;

package/dist/segment.d.ts

@@ -0,0 +1,6 @@
+export interface SigSegment {
+    text: string;
+    start: number;
+    end: number;
+}
+export declare function splitSigSegments(input: string): SigSegment[];

package/dist/segment.js

@@ -0,0 +1,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitSigSegments = splitSigSegments;
+const COMMA_SEGMENT_STARTERS = new Set([
+    "apply",
+    "take",
+    "instill",
+    "inject",
+    "spray",
+    "use",
+    "od",
+    "os",
+    "ou",
+    "re",
+    "le",
+    "be",
+    "right",
+    "left",
+    "both",
+    "each"
+]);
+const DIRECTIONAL_SEGMENT_STARTERS = new Set(["right", "left", "both", "each"]);
+const SEPARATOR_RULES = [
+    {
+        name: "double-slash",
+        match: (input, index) => (input.startsWith("//", index) ? 2 : 0)
+    },
+    {
+        name: "line-break",
+        match: (input, index) => {
+            const ch = input[index];
+            if (ch === "\r" && input[index + 1] === "\n") {
+                return 2;
+            }
+            return ch === "\n" || ch === "\r" ? 1 : 0;
+        }
+    },
+    {
+        name: "pipe",
+        match: (input, index) => input[index] === "|" && hasNonWhitespaceAround(input, index) ? consumePipeRun(input, index) : 0
+    },
+    {
+        name: "plus",
+        match: (input, index) => input[index] === "+" && hasNonWhitespaceAround(input, index) ? 1 : 0
+    },
+    {
+        name: "slash-divider",
+        match: (input, index) => input[index] === "/" && isDividerSlash(input, index) ? 1 : 0
+    },
+    {
+        name: "comma-clause",
+        match: (input, index, currentStart) => input[index] === "," && shouldSplitComma(input, index, currentStart) ? 1 : 0
+    }
+];
+function splitSigSegments(input) {
+    const segments = [];
+    let currentStart = 0;
+    let depth = 0;
+    const pushSegment = (rawStart, rawEnd) => {
+        let start = rawStart;
+        let end = rawEnd;
+        while (start < end && /\s/.test(input[start])) {
+            start += 1;
+        }
+        while (end > start && /\s/.test(input[end - 1])) {
+            end -= 1;
+        }
+        if (end <= start) {
+            return;
+        }
+        segments.push({
+            text: input.slice(start, end),
+            start,
+            end
+        });
+    };
+    for (let index = 0; index < input.length; index += 1) {
+        const ch = input[index];
+        if (ch === "(" || ch === "[" || ch === "{") {
+            depth += 1;
+            continue;
+        }
+        if ((ch === ")" || ch === "]" || ch === "}") && depth > 0) {
+            depth -= 1;
+            continue;
+        }
+        if (depth > 0) {
+            continue;
+        }
+        for (const rule of SEPARATOR_RULES) {
+            const length = rule.match(input, index, currentStart);
+            if (!length) {
+                continue;
+            }
+            pushSegment(currentStart, index);
+            currentStart = index + length;
+            index = currentStart - 1;
+            break;
+        }
+    }
+    pushSegment(currentStart, input.length);
+    if (segments.length > 0) {
+        return segments;
+    }
+    const fallback = input.trim();
+    if (!fallback) {
+        return [];
+    }
+    const start = input.indexOf(fallback);
+    return [{ text: fallback, start, end: start + fallback.length }];
+}
+function hasNonWhitespaceAround(input, index) {
+    const left = previousNonWhitespace(input, index - 1);
+    const right = nextNonWhitespace(input, index + 1);
+    return left !== undefined && right !== undefined;
+}
+function isDividerSlash(input, index) {
+    var _a, _b;
+    if (input[index - 1] === "/" || input[index + 1] === "/") {
+        return false;
+    }
+    const previous = previousNonWhitespace(input, index - 1);
+    const next = nextNonWhitespace(input, index + 1);
+    if (previous === undefined || next === undefined) {
+        return false;
+    }
+    if (/\d/.test(previous) && /\d/.test(next)) {
+        return false;
+    }
+    return /\s/.test((_a = input[index - 1]) !== null && _a !== void 0 ? _a : "") || /\s/.test((_b = input[index + 1]) !== null && _b !== void 0 ? _b : "");
+}
+function shouldSplitComma(input, index, currentStart) {
+    var _a, _b;
+    if (!hasNonWhitespaceAround(input, index)) {
+        return false;
+    }
+    const left = input.slice(currentStart, index).trim();
+    const right = input.slice(index + 1).trim();
+    if (!left || !right) {
+        return false;
+    }
+    if (startsWithTimeExpression(right)) {
+        return false;
+    }
+    const rightToken = (_b = (_a = right.match(/^([a-z]+|\d+(?:\.\d+)?)/i)) === null || _a === void 0 ? void 0 : _a[1]) === null || _b === void 0 ? void 0 : _b.toLowerCase();
+    if (!rightToken) {
+        return false;
+    }
+    if (/^\d/.test(rightToken)) {
+        return true;
+    }
+    if (COMMA_SEGMENT_STARTERS.has(rightToken)) {
+        if (DIRECTIONAL_SEGMENT_STARTERS.has(rightToken)) {
+            return looksLikeDirectionalClause(right);
+        }
+        return true;
+    }
+    return false;
+}
+function looksLikeDirectionalClause(text) {
+    const normalized = text.trim().toLowerCase();
+    if (!normalized) {
+        return false;
+    }
+    if (/\b\d+(?:\.\d+)?\b/.test(normalized)) {
+        return true;
+    }
+    return /\b(once|twice|thrice|daily|bid|tid|qid|q\d+[a-z0-9/-]*|every|prn|hs|morning|lunch|dinner|noon|night|weekly|monthly)\b/.test(normalized);
+}
+function startsWithTimeExpression(text) {
+    const trimmed = text.replace(/^\s+/, "");
+    if (!trimmed) {
+        return false;
+    }
+    return (/^@\s*\d{1,2}([:.]\d{2})?\s*(am|pm)?\b/i.test(trimmed) ||
+        /^\d{1,2}[:.]\d{2}\s*(am|pm)?\b/i.test(trimmed) ||
+        /^\d{1,2}\s*(am|pm)\b/i.test(trimmed));
+}
+function previousNonWhitespace(input, index) {
+    for (let cursor = index; cursor >= 0; cursor -= 1) {
+        const ch = input[cursor];
+        if (!/\s/.test(ch)) {
+            return ch;
+        }
+    }
+    return undefined;
+}
+function nextNonWhitespace(input, index) {
+    for (let cursor = index; cursor < input.length; cursor += 1) {
+        const ch = input[cursor];
+        if (!/\s/.test(ch)) {
+            return ch;
+        }
+    }
+    return undefined;
+}
+function consumePipeRun(input, index) {
+    let cursor = index;
+    while (cursor < input.length && input[cursor] === "|") {
+        cursor += 1;
+    }
+    return cursor - index;
+}

package/dist/types.d.ts

@@ -297,6 +297,13 @@ export interface FormatOptions {
     locale?: "en" | "th" | string;
     i18n?: SigTranslationConfig;
 }
+export interface FormatBatchOptions extends FormatOptions {
+    /**
+     * String inserted between formatted clauses. Defaults to ", " so output can
+     * be fed back into `parseSig` as a multi-clause instruction.
+     */
+    separator?: string;
+}
 export interface BodySiteCode {
     code: string;
     display?: string;
@@ -535,6 +542,61 @@ export interface ParseResult {
         }>;
     };
 }
+export interface ParseBatchSegmentMeta {
+    index: number;
+    text: string;
+    range: TextRange;
+}
+export interface ParseBatchResult {
+    input: string;
+    count: number;
+    items: ParseResult[];
+    /**
+     * Legacy compatibility field mirroring the first parsed item so existing
+     * single-sig integrations can migrate incrementally.
+     */
+    fhir: FhirDosage;
+    /**
+     * Legacy compatibility field mirroring the first parsed item so existing
+     * single-sig integrations can migrate incrementally.
+     */
+    shortText: string;
+    /**
+     * Legacy compatibility field mirroring the first parsed item so existing
+     * single-sig integrations can migrate incrementally.
+     */
+    longText: string;
+    warnings: string[];
+    meta: {
+        consumedTokens: string[];
+        leftoverText?: string;
+        normalized: {
+            route?: RouteCode;
+            unit?: string;
+            site?: {
+                text?: string;
+                coding?: BodySiteCode;
+            };
+            prnReason?: {
+                text?: string;
+                coding?: FhirCoding;
+            };
+            additionalInstructions?: Array<{
+                text?: string;
+                coding?: FhirCoding;
+            }>;
+        };
+        siteLookups?: Array<{
+            request: SiteCodeLookupRequest;
+            suggestions: SiteCodeSuggestion[];
+        }>;
+        prnReasonLookups?: Array<{
+            request: PrnReasonLookupRequest;
+            suggestions: PrnReasonSuggestion[];
+        }>;
+        segments: ParseBatchSegmentMeta[];
+    };
+}
 export interface LintIssue {
     /** Human-readable description of why the segment could not be parsed. */
     message: string;
@@ -551,6 +613,20 @@ export interface LintResult {
     /** Segments of the input that could not be interpreted. */
     issues: LintIssue[];
 }
+export interface LintBatchResult {
+    input: string;
+    count: number;
+    items: LintResult[];
+    /**
+     * Legacy compatibility fields mirroring the first parsed item so existing
+     * consumers of `lintSig` can migrate incrementally.
+     */
+    result: ParseResult;
+    issues: LintIssue[];
+    meta: {
+        segments: ParseBatchSegmentMeta[];
+    };
+}
 /**
  * Maps EventTiming codes (or other institution-specific timing strings) to
  * 24-hour clock representations such as "08:00".

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ezmedicationinput",
-  "version": "0.1.34",
+  "version": "0.1.35",
   "description": "Parse concise medication sigs into FHIR R5 Dosage JSON",
   "type": "module",
   "main": "dist/index.js",