ezmedicationinput 0.1.38 → 0.1.40

package/README.md

@@ -184,6 +184,8 @@ Highlights:
 - Supports multiple timing tokens in sequence (e.g. `1 tab po morn hs`).
 - Surfaces PRN reasons from built-ins or custom `prnReasons` entries while
   preserving numeric doses pulled from the typed prefix.
+- When `enableMealDashSyntax` is enabled, suggests dash-based meal patterns
+  (e.g. `1-0-1`, `1-0-0-1 ac`) only when dash syntax is being typed.
 
 ## Dictionaries
 

package/dist/index.js

@@ -58,6 +58,15 @@ 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; } });
+const REPEAT_NON_ANCHOR_KEYS = [
+    "count",
+    "frequency",
+    "frequencyMax",
+    "period",
+    "periodMax",
+    "periodUnit",
+    "offset"
+];
 function parseMealDashValues(token) {
     if (!/^[0-9]+(?:\.[0-9]+)?(?:-[0-9]+(?:\.[0-9]+)?){2,3}$/.test(token)) {
         return undefined;
@@ -155,6 +164,189 @@ function toSegmentMeta(segments) {
         range: { start: segment.start, end: segment.end }
     }));
 }
+/**
+ * Deep equality helper for plain JSON-like parser output objects.
+ *
+ * @param left Left-side value.
+ * @param right Right-side value.
+ * @returns `true` when both values are structurally equal.
+ */
+function deepEqual(left, right) {
+    if (left === right) {
+        return true;
+    }
+    if (left === null || right === null) {
+        return left === right;
+    }
+    if (Array.isArray(left) || Array.isArray(right)) {
+        if (!Array.isArray(left) || !Array.isArray(right)) {
+            return false;
+        }
+        if (left.length !== right.length) {
+            return false;
+        }
+        for (let i = 0; i < left.length; i += 1) {
+            if (!deepEqual(left[i], right[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    if (typeof left !== "object" || typeof right !== "object") {
+        return false;
+    }
+    const leftRecord = left;
+    const rightRecord = right;
+    const leftKeys = Object.keys(leftRecord).filter((key) => leftRecord[key] !== undefined);
+    const rightKeys = Object.keys(rightRecord).filter((key) => rightRecord[key] !== undefined);
+    if (leftKeys.length !== rightKeys.length) {
+        return false;
+    }
+    for (const key of leftKeys) {
+        if (!Object.prototype.hasOwnProperty.call(rightRecord, key)) {
+            return false;
+        }
+        if (!deepEqual(leftRecord[key], rightRecord[key])) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Compares two string arrays as sets.
+ *
+ * @param left Left array.
+ * @param right Right array.
+ * @returns `true` when both arrays contain the same unique values.
+ */
+function sameStringSet(left, right) {
+    const a = left !== null && left !== void 0 ? left : [];
+    const b = right !== null && right !== void 0 ? right : [];
+    if (a.length !== b.length) {
+        return false;
+    }
+    const set = new Set(a);
+    if (set.size !== b.length) {
+        return false;
+    }
+    for (const value of b) {
+        if (!set.has(value)) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Determines whether a repeat block only uses merge-safe anchor fields.
+ *
+ * @param repeat FHIR timing repeat payload.
+ * @returns `true` when repeat contains only `when`/`timeOfDay`/`dayOfWeek`.
+ */
+function isMergeableAnchorRepeat(repeat) {
+    if (!repeat) {
+        return true;
+    }
+    for (const key of REPEAT_NON_ANCHOR_KEYS) {
+        if (repeat[key] !== undefined) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Checks whether two parsed items can be merged without changing semantics.
+ *
+ * @param base Existing merged item candidate.
+ * @param next Incoming parsed item.
+ * @returns `true` when both items differ only by merge-safe timing anchors.
+ */
+function canMergeTimingOnly(base, next) {
+    const baseTiming = base.fhir.timing;
+    const nextTiming = next.fhir.timing;
+    const baseRepeat = baseTiming === null || baseTiming === void 0 ? void 0 : baseTiming.repeat;
+    const nextRepeat = nextTiming === null || nextTiming === void 0 ? void 0 : nextTiming.repeat;
+    if (!baseRepeat || !nextRepeat) {
+        return false;
+    }
+    if (!isMergeableAnchorRepeat(baseRepeat) || !isMergeableAnchorRepeat(nextRepeat)) {
+        return false;
+    }
+    if (!sameStringSet(baseRepeat.dayOfWeek, nextRepeat.dayOfWeek)) {
+        return false;
+    }
+    if (!deepEqual(baseTiming === null || baseTiming === void 0 ? void 0 : baseTiming.code, nextTiming === null || nextTiming === void 0 ? void 0 : nextTiming.code)) {
+        return false;
+    }
+    if (!deepEqual(baseTiming === null || baseTiming === void 0 ? void 0 : baseTiming.event, nextTiming === null || nextTiming === void 0 ? void 0 : nextTiming.event)) {
+        return false;
+    }
+    return (deepEqual(base.fhir.doseAndRate, next.fhir.doseAndRate) &&
+        deepEqual(base.fhir.route, next.fhir.route) &&
+        deepEqual(base.fhir.site, next.fhir.site) &&
+        deepEqual(base.fhir.additionalInstruction, next.fhir.additionalInstruction) &&
+        deepEqual(base.fhir.asNeededBoolean, next.fhir.asNeededBoolean) &&
+        deepEqual(base.fhir.asNeededFor, next.fhir.asNeededFor));
+}
+/**
+ * Returns a stable unique list preserving first-seen order.
+ *
+ * @param values Input values.
+ * @returns Deduplicated values in insertion order.
+ */
+function uniqueStrings(values) {
+    const seen = new Set();
+    const output = [];
+    for (const value of values) {
+        if (!seen.has(value)) {
+            seen.add(value);
+            output.push(value);
+        }
+    }
+    return output;
+}
+/**
+ * Merges two parse results that are known to be timing-compatible.
+ *
+ * @param base Existing merged result.
+ * @param next Next result to fold into `base`.
+ * @param options Parse options used to render localized text.
+ * @returns New merged parse result.
+ */
+function mergeParseResults(base, next, options) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
+    const baseRepeat = (_b = (_a = base.fhir.timing) === null || _a === void 0 ? void 0 : _a.repeat) !== null && _b !== void 0 ? _b : {};
+    const nextRepeat = (_d = (_c = next.fhir.timing) === null || _c === void 0 ? void 0 : _c.repeat) !== null && _d !== void 0 ? _d : {};
+    const mergedWhen = uniqueStrings([...((_e = baseRepeat.when) !== null && _e !== void 0 ? _e : []), ...((_f = nextRepeat.when) !== null && _f !== void 0 ? _f : [])]);
+    const mergedTimeOfDay = uniqueStrings([...((_g = baseRepeat.timeOfDay) !== null && _g !== void 0 ? _g : []), ...((_h = nextRepeat.timeOfDay) !== null && _h !== void 0 ? _h : [])]).sort();
+    const mergedRepeat = Object.assign(Object.assign(Object.assign(Object.assign({}, baseRepeat), (nextRepeat.dayOfWeek ? { dayOfWeek: nextRepeat.dayOfWeek } : {})), (mergedWhen.length ? { when: mergedWhen } : {})), (mergedTimeOfDay.length ? { timeOfDay: mergedTimeOfDay } : {}));
+    const mergedFhir = Object.assign(Object.assign({}, base.fhir), { timing: Object.assign(Object.assign({}, ((_j = base.fhir.timing) !== null && _j !== void 0 ? _j : {})), { repeat: mergedRepeat }) });
+    const shortText = formatSig(mergedFhir, "short", options);
+    const longText = formatSig(mergedFhir, "long", options);
+    mergedFhir.text = longText;
+    return {
+        fhir: mergedFhir,
+        shortText,
+        longText,
+        warnings: uniqueStrings([...((_k = base.warnings) !== null && _k !== void 0 ? _k : []), ...((_l = next.warnings) !== null && _l !== void 0 ? _l : [])]),
+        meta: Object.assign(Object.assign({}, base.meta), { consumedTokens: uniqueStrings([...((_m = base.meta.consumedTokens) !== null && _m !== void 0 ? _m : []), ...((_o = next.meta.consumedTokens) !== null && _o !== void 0 ? _o : [])]), leftoverText: uniqueStrings([base.meta.leftoverText, next.meta.leftoverText].filter((value) => !!value)).join(" ").trim() || undefined, siteLookups: [...((_p = base.meta.siteLookups) !== null && _p !== void 0 ? _p : []), ...((_q = next.meta.siteLookups) !== null && _q !== void 0 ? _q : [])], prnReasonLookups: [...((_r = base.meta.prnReasonLookups) !== null && _r !== void 0 ? _r : []), ...((_s = next.meta.prnReasonLookups) !== null && _s !== void 0 ? _s : [])] })
+    };
+}
+/**
+ * Appends a parsed segment result to the batch, reusing the current item when
+ * timing-only expansion can be represented as a single dosage element.
+ *
+ * @param items Accumulated batch items.
+ * @param next Newly parsed segment result.
+ * @param options Parse options used to format merged text.
+ */
+function appendParseResult(items, next, options) {
+    const previous = items[items.length - 1];
+    if (previous && canMergeTimingOnly(previous, next)) {
+        items[items.length - 1] = mergeParseResults(previous, next, options);
+        return;
+    }
+    items.push(next);
+}
 function parseSig(input, options) {
     const segments = expandMealDashSegments((0, segment_1.splitSigSegments)(input), options);
     const carry = {};
@@ -166,7 +358,7 @@ function parseSig(input, options) {
         (0, parser_1.applySiteCoding)(internal, options);
         const result = buildParseResult(internal, options);
         rebaseParseResult(result, input, segment.start);
-        results.push(result);
+        appendParseResult(results, result, options);
         updateCarryForward(carry, internal);
     }
     const legacy = resolveLegacyParseResult(results, input, options);
@@ -232,7 +424,7 @@ function parseSigAsync(input, options) {
             yield (0, parser_1.applySiteCodingAsync)(internal, options);
             const result = buildParseResult(internal, options);
             rebaseParseResult(result, input, segment.start);
-            results.push(result);
+            appendParseResult(results, result, options);
             updateCarryForward(carry, internal);
         }
         const legacy = resolveLegacyParseResult(results, input, options);

package/dist/maps.js

@@ -668,6 +668,7 @@ exports.EVENT_TIMING_TOKENS = {
     pcd: types_1.EventTiming["After Lunch"],
     pcv: types_1.EventTiming["After Dinner"],
     wm: types_1.EventTiming.Meal,
+    c: types_1.EventTiming.Meal,
     "with meals": types_1.EventTiming.Meal,
     "with meal": types_1.EventTiming.Meal,
     "with food": types_1.EventTiming.Meal,

package/dist/parser.js

@@ -780,26 +780,84 @@ function parseTimeToFhir(timeStr) {
     const m = minute < 10 ? `0${minute}` : `${minute}`;
     return `${h}:${m}:00`;
 }
+function extractAttachedAtTimeToken(lower) {
+    if (lower.length <= 1) {
+        return undefined;
+    }
+    if (lower.charAt(0) === "@") {
+        const candidate = lower.slice(1);
+        return parseTimeToFhir(candidate) ? candidate : undefined;
+    }
+    if (lower.startsWith("at") && lower.length > 2 && /^\d/.test(lower.charAt(2))) {
+        const candidate = lower.slice(2);
+        return parseTimeToFhir(candidate) ? candidate : undefined;
+    }
+    return undefined;
+}
+function isAtPrefixToken(lower) {
+    return lower === "@" || lower === "at" || extractAttachedAtTimeToken(lower) !== undefined;
+}
 function tryParseTimeBasedSchedule(internal, tokens, index) {
     const token = tokens[index];
     if (internal.consumed.has(token.index))
         return false;
-    let isAtPrefix = token.lower === "@" || token.lower === "at";
+    const attachedAtTime = extractAttachedAtTimeToken(token.lower);
+    const isAtPrefix = isAtPrefixToken(token.lower);
     if (!isAtPrefix && !/^\d/.test(token.lower))
         return false;
     let nextIndex = index;
-    if (isAtPrefix)
-        nextIndex++;
     const times = [];
     const consumedIndices = [];
     const timeTokens = [];
-    if (isAtPrefix) {
+    if (token.lower === "@" || token.lower === "at") {
+        consumedIndices.push(index);
+        nextIndex++;
+    }
+    else if (attachedAtTime) {
+        let timeStr = attachedAtTime;
+        const lookaheadIndices = [];
+        if (!timeStr.includes("am") && !timeStr.includes("pm")) {
+            const ampmToken = tokens[index + 1];
+            if (ampmToken &&
+                !internal.consumed.has(ampmToken.index) &&
+                (ampmToken.lower === "am" || ampmToken.lower === "pm")) {
+                timeStr += ampmToken.lower;
+                lookaheadIndices.push(index + 1);
+            }
+        }
+        const compactTime = parseTimeToFhir(timeStr);
+        if (!compactTime) {
+            return false;
+        }
+        times.push(compactTime);
+        timeTokens.push(timeStr);
         consumedIndices.push(index);
+        for (const idx of lookaheadIndices) {
+            consumedIndices.push(idx);
+        }
+        nextIndex = index + 1 + lookaheadIndices.length;
     }
     while (nextIndex < tokens.length) {
         const nextToken = tokens[nextIndex];
         if (!nextToken || internal.consumed.has(nextToken.index))
             break;
+        if ((nextToken.lower === "," || nextToken.lower === "and") && times.length > 0) {
+            const peekToken = tokens[nextIndex + 1];
+            if (peekToken && !internal.consumed.has(peekToken.index)) {
+                let peekStr = peekToken.lower;
+                const ampmToken = tokens[nextIndex + 2];
+                if (ampmToken &&
+                    !internal.consumed.has(ampmToken.index) &&
+                    (ampmToken.lower === "am" || ampmToken.lower === "pm")) {
+                    peekStr += ampmToken.lower;
+                }
+                if (parseTimeToFhir(peekStr)) {
+                    consumedIndices.push(nextIndex);
+                    nextIndex++;
+                    continue;
+                }
+            }
+        }
         let timeStr = nextToken.lower;
         let lookaheadIndices = [];
         // Look ahead for am/pm if current token is just a number or doesn't have am/pm
@@ -1066,6 +1124,11 @@ function splitToken(token) {
     if (/^[0-9]+(?:\.[0-9]+)?$/.test(token)) {
         return [token];
     }
+    const compactPoMeal = token.match(/^(po)(ac|pc|c)$/i);
+    if (compactPoMeal) {
+        const [, po, meal] = compactPoMeal;
+        return [po, meal];
+    }
     if (/^[A-Za-z]+$/.test(token)) {
         return [token];
     }
@@ -1077,6 +1140,11 @@ function splitToken(token) {
     const match = token.match(/^([0-9]+(?:\.[0-9]+)?)([A-Za-z]+)$/);
     if (match) {
         const [, num, unit] = match;
+        const compactPoMealUnit = unit.match(/^(po)(ac|pc|c)$/i);
+        if (compactPoMealUnit) {
+            const [, po, meal] = compactPoMealUnit;
+            return [num, po, meal];
+        }
         if (!/^x\d+/i.test(unit) && !/^q\d+/i.test(unit)) {
             return [num, unit];
         }
@@ -1514,7 +1582,7 @@ function isTimingAnchorOrPrefix(tokens, index, prnReasonStart) {
         maps_1.TIMING_ABBREVIATIONS[lower] ||
         (comboKey && COMBO_EVENT_TIMINGS[comboKey]) ||
         (lower === "pc" || lower === "ac" || lower === "after" || lower === "before") ||
-        (lower === "at" || lower === "@" || lower === "on" || lower === "with") ||
+        (isAtPrefixToken(lower) || lower === "on" || lower === "with") ||
         /^\d/.test(lower));
 }
 function parseAnchorSequence(internal, tokens, index, prefixCode) {
@@ -1963,11 +2031,11 @@ function parseInternal(input, options) {
                 : types_1.EventTiming["Before Meal"]);
             continue;
         }
-        if (token.lower === "at" || token.lower === "@" || token.lower === "on" || token.lower === "with") {
-            if (parseAnchorSequence(internal, tokens, i)) {
+        if (isAtPrefixToken(token.lower) || token.lower === "on" || token.lower === "with") {
+            if (tryParseTimeBasedSchedule(internal, tokens, i)) {
                 continue;
             }
-            if (tryParseTimeBasedSchedule(internal, tokens, i)) {
+            if (parseAnchorSequence(internal, tokens, i)) {
                 continue;
             }
             // If none of the above consume it, and it's a known anchor prefix, mark it

package/dist/schedule.js

@@ -280,6 +280,44 @@ function getLocalWeekday(date, timeZone) {
             throw new Error(`Unexpected weekday token: ${formatted}`);
     }
 }
+function getLocalDayNumber(date, timeZone) {
+    const { year, month, day } = getTimeParts(date, timeZone);
+    return Math.floor(Date.UTC(year, month - 1, day) / (24 * 60 * 60 * 1000));
+}
+function getLocalMonthIndex(date, timeZone) {
+    const { year, month } = getTimeParts(date, timeZone);
+    return year * 12 + (month - 1);
+}
+function isDateAlignedToPeriodCycle(candidateDay, anchorDay, repeat, timeZone) {
+    const period = repeat.period;
+    const periodUnit = repeat.periodUnit;
+    if (!period || period <= 0 || !periodUnit) {
+        return true;
+    }
+    if (periodUnit === "d") {
+        const deltaDays = getLocalDayNumber(candidateDay, timeZone) - getLocalDayNumber(anchorDay, timeZone);
+        return deltaDays >= 0 && deltaDays % period === 0;
+    }
+    if (periodUnit === "wk") {
+        const deltaDays = getLocalDayNumber(candidateDay, timeZone) - getLocalDayNumber(anchorDay, timeZone);
+        if (deltaDays < 0) {
+            return false;
+        }
+        const deltaWeeks = Math.floor(deltaDays / 7);
+        return deltaWeeks % period === 0;
+    }
+    if (periodUnit === "mo") {
+        const deltaMonths = getLocalMonthIndex(candidateDay, timeZone) - getLocalMonthIndex(anchorDay, timeZone);
+        return deltaMonths >= 0 && deltaMonths % period === 0;
+    }
+    if (periodUnit === "a") {
+        const candidateYear = getTimeParts(candidateDay, timeZone).year;
+        const anchorYear = getTimeParts(anchorDay, timeZone).year;
+        const deltaYears = candidateYear - anchorYear;
+        return deltaYears >= 0 && deltaYears % period === 0;
+    }
+    return true;
+}
 /** Parses arbitrary string/Date inputs into a valid Date instance. */
 function coerceDate(value, label) {
     const date = value instanceof Date ? value : new Date(value);
@@ -706,12 +744,29 @@ function nextDueDoses(dosage, options) {
         (!repeat.frequency ||
             repeat.periodUnit !== "d" ||
             (repeat.frequency === 1 && repeat.period > 1));
-    if (treatAsInterval) {
+    const supportsDayFilteredInterval = isDayFilteredIntervalSupported(repeat, enforceDayFilter);
+    if (treatAsInterval && supportsDayFilteredInterval) {
         // True interval schedules advance from the order start in fixed units. The
         // timing.code remains advisory so we only rely on the period/unit fields.
         const candidates = generateIntervalSeries(baseTime, from, effectiveLimit, repeat, timeZone, dayFilter, enforceDayFilter, orderedAt);
         return candidates;
     }
+    if (enforceDayFilter &&
+        repeat.period &&
+        repeat.periodUnit &&
+        (repeat.periodUnit === "wk" || repeat.periodUnit === "mo" || repeat.periodUnit === "a")) {
+        return generateDayFilteredPeriodSeries({
+            repeat,
+            timeZone,
+            dayFilter,
+            anchorDay: startOfLocalDay(baseTime, timeZone),
+            startDay: from,
+            from,
+            orderedAt,
+            limit: effectiveLimit,
+            defaultClock: toLocalClock(baseTime, timeZone)
+        }).slice(0, effectiveLimit);
+    }
     if (repeat.frequency && repeat.period && repeat.periodUnit) {
         // Pure frequency schedules (e.g., BID/TID) rely on institution clocks that
         // clinicians expect. These can be overridden via configuration when
@@ -851,7 +906,8 @@ function derivePriorCountFromHistory(timing, repeat, config, orderedAt, from, ti
         (!repeat.frequency ||
             repeat.periodUnit !== "d" ||
             (repeat.frequency === 1 && repeat.period > 1));
-    if (treatAsInterval) {
+    const supportsDayFilteredInterval = isDayFilteredIntervalSupported(repeat, enforceDayFilter);
+    if (treatAsInterval && supportsDayFilteredInterval) {
         const increment = createIntervalStepper(repeat, timeZone);
         if (!increment) {
             return count;
@@ -875,6 +931,24 @@ function derivePriorCountFromHistory(timing, repeat, config, orderedAt, from, ti
         }
         return count;
     }
+    if (enforceDayFilter &&
+        repeat.period &&
+        repeat.periodUnit &&
+        (repeat.periodUnit === "wk" || repeat.periodUnit === "mo" || repeat.periodUnit === "a")) {
+        const generated = generateDayFilteredPeriodSeries({
+            repeat,
+            timeZone,
+            dayFilter,
+            anchorDay: startOfLocalDay(orderedAt, timeZone),
+            startDay: orderedAt,
+            from: orderedAt,
+            to: from,
+            orderedAt,
+            limit: normalizedCount !== null && normalizedCount !== void 0 ? normalizedCount : 31 * 365,
+            defaultClock: toLocalClock(orderedAt, timeZone)
+        });
+        return count + generated.length;
+    }
     if (repeat.frequency && repeat.period && repeat.periodUnit) {
         const clocks = resolveFrequencyClocks(timing, config);
         if (clocks.length === 0) {
@@ -966,6 +1040,10 @@ function generateIntervalSeries(baseTime, from, effectiveLimit, repeat, timeZone
 }
 /**
  * Builds a function that advances a Date according to repeat.period/unit.
+ *
+ * @param repeat FHIR repeat object containing `period` and `periodUnit`.
+ * @param timeZone IANA timezone used for calendar-aware month/year stepping.
+ * @returns Stepper function advancing one interval, or `null` when unsupported.
  */
 function createIntervalStepper(repeat, timeZone) {
     const { period, periodUnit } = repeat;
@@ -993,7 +1071,14 @@ function createIntervalStepper(repeat, timeZone) {
     }
     return null;
 }
-/** Adds calendar months while respecting varying month lengths and DST. */
+/**
+ * Adds calendar months while respecting varying month lengths and DST.
+ *
+ * @param date Starting instant.
+ * @param months Number of calendar months to add.
+ * @param timeZone IANA timezone used for wall-clock preservation.
+ * @returns Shifted date preserving local clock and clamped day-of-month.
+ */
 function addCalendarMonths(date, months, timeZone) {
     const { year, month, day, hour, minute, second } = getTimeParts(date, timeZone);
     const targetMonthIndex = month - 1 + months;
@@ -1014,8 +1099,114 @@ function addCalendarMonths(date, months, timeZone) {
     }
     return final;
 }
+/**
+ * Determines whether interval stepping can safely combine with a day-of-week filter.
+ *
+ * @param repeat FHIR timing repeat object containing period unit metadata.
+ * @param enforceDayFilter Whether a `dayOfWeek` filter is active for this schedule.
+ * @returns `true` when interval stepping should be used directly; otherwise fallback logic is required.
+ */
+function isDayFilteredIntervalSupported(repeat, enforceDayFilter) {
+    if (!enforceDayFilter) {
+        return true;
+    }
+    return (repeat.periodUnit === "s" ||
+        repeat.periodUnit === "min" ||
+        repeat.periodUnit === "h" ||
+        repeat.periodUnit === "d");
+}
+/**
+ * Expands weekly/monthly/yearly day-filtered schedules into concrete dose timestamps.
+ *
+ * @param options Configuration describing bounds, cadence, and clock defaults.
+ * @param options.repeat FHIR repeat block driving cadence and cycle alignment.
+ * @param options.timeZone IANA timezone used for local weekday and clock resolution.
+ * @param options.dayFilter Set of lowercased weekdays that are allowed (e.g. `mon`, `tue`).
+ * @param options.anchorDay Cycle anchor day used to determine period alignment.
+ * @param options.startDay First local day to begin scanning.
+ * @param options.from Inclusive lower bound for candidate timestamps.
+ * @param options.to Optional exclusive upper bound for candidate timestamps.
+ * @param options.orderedAt Optional lower bound representing the order start.
+ * @param options.limit Maximum number of timestamps to emit.
+ * @param options.defaultClock Default local clock (`HH:MM:SS`) when no explicit clock is provided.
+ * @returns Sorted zoned ISO timestamps matching the requested cadence and bounds.
+ */
+function generateDayFilteredPeriodSeries(options) {
+    const { repeat, timeZone, dayFilter, anchorDay, startDay, from, to, orderedAt, limit, defaultClock } = options;
+    if (limit <= 0) {
+        return [];
+    }
+    const results = [];
+    const seen = new Set();
+    const clocks = [defaultClock !== null && defaultClock !== void 0 ? defaultClock : "08:00:00"];
+    let currentDay = startOfLocalDay(startDay, timeZone);
+    let iterations = 0;
+    const startMs = currentDay.getTime();
+    const estimatedDays = to
+        ? Math.max(1, Math.ceil((to.getTime() - startMs) / (24 * 60 * 60 * 1000)))
+        : limit * 31;
+    const maxIterations = Math.max(limit * 31, estimatedDays + 31);
+    while (results.length < limit &&
+        iterations < maxIterations &&
+        (!to || currentDay < to)) {
+        const weekday = getLocalWeekday(currentDay, timeZone);
+        const inPeriodCycle = isDateAlignedToPeriodCycle(currentDay, anchorDay, repeat, timeZone);
+        if (inPeriodCycle && dayFilter.has(weekday)) {
+            for (const clock of clocks) {
+                const zoned = makeZonedDateFromDay(currentDay, timeZone, clock);
+                if (!zoned) {
+                    continue;
+                }
+                if (zoned < from) {
+                    continue;
+                }
+                if (to && zoned >= to) {
+                    continue;
+                }
+                if (orderedAt && zoned < orderedAt) {
+                    continue;
+                }
+                const iso = formatZonedIso(zoned, timeZone);
+                if (!seen.has(iso)) {
+                    seen.add(iso);
+                    results.push(iso);
+                    if (results.length === limit) {
+                        break;
+                    }
+                }
+            }
+        }
+        currentDay = addLocalDays(currentDay, 1, timeZone);
+        iterations += 1;
+    }
+    return results;
+}
+/**
+ * Formats a date into a local `HH:MM:SS` clock for the supplied timezone.
+ *
+ * @param date Source instant.
+ * @param timeZone IANA timezone to interpret the instant.
+ * @returns Local wall-clock time in `HH:MM:SS` format.
+ */
+function toLocalClock(date, timeZone) {
+    const parts = getTimeParts(date, timeZone);
+    const twoDigits = (value) => (value < 10 ? `0${value}` : `${value}`);
+    const h = twoDigits(parts.hour);
+    const m = twoDigits(parts.minute);
+    const s = twoDigits(parts.second);
+    return `${h}:${m}:${s}`;
+}
 /**
  * Internal helper to count dose events within a time range.
+ *
+ * @param dosage Dosage definition with timing metadata.
+ * @param from Inclusive lower time bound for counting.
+ * @param to Exclusive upper time bound for counting.
+ * @param config Scheduling configuration (timezone, clocks, offsets).
+ * @param baseTime Anchor instant used for interval alignment.
+ * @param orderedAt Optional order timestamp used as an additional lower bound.
+ * @param limit Optional hard cap on emitted candidates to avoid runaway loops.
+ * @returns Number of unique dose events in the requested window.
  */
 function countScheduleEvents(dosage, from, to, config, baseTime, orderedAt, limit) {
     var _a, _b, _c;
@@ -1098,9 +1289,9 @@ function countScheduleEvents(dosage, from, to, config, baseTime, orderedAt, limi
         !!repeat.periodUnit &&
         (!repeat.frequency ||
             repeat.periodUnit !== "d" ||
-            (repeat.frequency === 1 && repeat.period > 1)) &&
-        !enforceDayFilter;
-    if (treatAsInterval) {
+            (repeat.frequency === 1 && repeat.period > 1));
+    const supportsDayFilteredInterval = isDayFilteredIntervalSupported(repeat, enforceDayFilter);
+    if (treatAsInterval && supportsDayFilteredInterval) {
         const increment = createIntervalStepper(repeat, timeZone);
         if (!increment)
             return count;
@@ -1149,24 +1340,23 @@ function countScheduleEvents(dosage, from, to, config, baseTime, orderedAt, limi
         }
     }
     // Fallback for dayOfWeek with period/periodUnit but no explicit frequency/clocks
-    if (enforceDayFilter && repeat.period && repeat.periodUnit) {
-        const clocks = ["08:00:00"]; // Default to morning if no times specified
-        let currentDayIter = startOfLocalDay(from, timeZone);
-        let iter = 0;
-        const maxIter = limit !== undefined ? limit * 31 : 365 * 31;
-        while (count < (limit !== null && limit !== void 0 ? limit : Infinity) && currentDayIter < to && iter < maxIter) {
-            const weekday = getLocalWeekday(currentDayIter, timeZone);
-            if (dayFilter.has(weekday)) {
-                for (const clock of clocks) {
-                    const zoned = makeZonedDateFromDay(currentDayIter, timeZone, clock);
-                    if (zoned)
-                        recordCandidate(zoned);
-                }
-            }
-            currentDayIter = addLocalDays(currentDayIter, 1, timeZone);
-            iter += 1;
-        }
-        return count;
+    if (enforceDayFilter &&
+        repeat.period &&
+        repeat.periodUnit &&
+        (repeat.periodUnit === "wk" || repeat.periodUnit === "mo" || repeat.periodUnit === "a")) {
+        const generated = generateDayFilteredPeriodSeries({
+            repeat,
+            timeZone,
+            dayFilter,
+            anchorDay: startOfLocalDay(baseTime, timeZone),
+            startDay: from,
+            from,
+            to,
+            orderedAt,
+            limit: limit !== null && limit !== void 0 ? limit : 365 * 31,
+            defaultClock: toLocalClock(baseTime, timeZone)
+        });
+        return count + generated.length;
     }
     return count;
 }

package/dist/suggest.js

@@ -729,6 +729,131 @@ function matchesPrefix(_candidate, candidateLower, context) {
     }
     return false;
 }
+function collectMatchedCandidates(candidates, limit, matcher) {
+    const suggestions = [];
+    const seen = new Set();
+    for (const candidate of candidates) {
+        const value = normalizeSpacing(candidate);
+        if (!value) {
+            continue;
+        }
+        const lower = value.toLowerCase();
+        if (seen.has(lower)) {
+            continue;
+        }
+        if (!matcher(value, lower)) {
+            continue;
+        }
+        seen.add(lower);
+        suggestions.push(value);
+        if (suggestions.length >= limit) {
+            break;
+        }
+    }
+    return suggestions;
+}
+function buildMealDashCoreVariants(prefixCore) {
+    var _a;
+    if (!prefixCore.includes("-") || prefixCore.includes("--")) {
+        return [];
+    }
+    const slots = prefixCore.split("-");
+    if (slots.length < 2 || slots.length > 4) {
+        return [];
+    }
+    if (!/^[0-9]+(?:\.[0-9]+)?$/.test((_a = slots[0]) !== null && _a !== void 0 ? _a : "")) {
+        return [];
+    }
+    for (let i = 1; i < slots.length; i += 1) {
+        const slot = slots[i];
+        if (slot.length === 0) {
+            continue;
+        }
+        if (!/^[0-9]+(?:\.[0-9]+)?$/.test(slot)) {
+            return [];
+        }
+    }
+    const variants = [];
+    const seen = new Set();
+    const addVariant = (value) => {
+        if (!seen.has(value)) {
+            seen.add(value);
+            variants.push(value);
+        }
+    };
+    const first = slots[0];
+    const fillBase = (targetLength) => {
+        const values = new Array(targetLength).fill("0");
+        values[0] = first;
+        for (let i = 1; i < targetLength; i += 1) {
+            if (i < slots.length && slots[i] !== "") {
+                values[i] = slots[i];
+            }
+        }
+        return values;
+    };
+    const base3 = fillBase(3);
+    const missingThird = slots.length < 3 || slots[2] === "";
+    if (missingThird && (slots.length === 1 || slots[1] === "" || slots[1] === "0")) {
+        const mirror = [...base3];
+        mirror[2] = first;
+        addVariant(mirror.join("-"));
+    }
+    addVariant(base3.join("-"));
+    const base4 = fillBase(4);
+    const missingFourth = slots.length < 4 || slots[3] === "";
+    if (missingFourth &&
+        (slots.length === 1 ||
+            slots[1] === "" ||
+            (slots[1] === "0" && (slots.length < 3 || slots[2] === "" || slots[2] === "0")))) {
+        const mirror = [...base4];
+        mirror[3] = first;
+        addVariant(mirror.join("-"));
+    }
+    addVariant(base4.join("-"));
+    return variants;
+}
+function suggestMealDashSyntax(prefix, limit, matcher) {
+    if (!prefix.includes("-")) {
+        return undefined;
+    }
+    const match = prefix.match(/^(\d+(?:-\d*){0,3})(?:\s+(ac|pc))?$/);
+    if (!match) {
+        return undefined;
+    }
+    const core = match[1];
+    const relation = match[2];
+    const coreVariants = buildMealDashCoreVariants(core);
+    if (coreVariants.length === 0) {
+        return undefined;
+    }
+    const suffixes = relation ? [` ${relation}`] : ["", " ac", " pc"];
+    const candidates = [];
+    for (const variant of coreVariants) {
+        for (const suffix of suffixes) {
+            candidates.push(`${variant}${suffix}`);
+        }
+    }
+    return collectMatchedCandidates(candidates, limit, matcher);
+}
+function suggestCompactOralMealTiming(prefix, limit, matcher) {
+    var _a, _b;
+    const match = prefix.match(/^(\d+(?:\.\d+)?)\s*(?:po\s*(c|ac|pc)|po(c|ac|pc))$/);
+    if (!match) {
+        return undefined;
+    }
+    const dose = normalizeSpacing(match[1]);
+    const timing = ((_b = (_a = match[2]) !== null && _a !== void 0 ? _a : match[3]) !== null && _b !== void 0 ? _b : "").toLowerCase();
+    const orderedTimings = timing === "c"
+        ? ["c", "ac", "pc"]
+        : timing === "ac"
+            ? ["ac", "c", "pc"]
+            : timing === "pc"
+                ? ["pc", "c", "ac"]
+                : ["c", "ac", "pc"];
+    const candidates = orderedTimings.map((token) => `${dose} po ${token}`);
+    return collectMatchedCandidates(candidates, limit, matcher);
+}
 function suggestSig(input, options) {
     var _a, _b;
     const limit = (_a = options === null || options === void 0 ? void 0 : options.limit) !== null && _a !== void 0 ? _a : DEFAULT_LIMIT;
@@ -768,5 +893,15 @@ function suggestSig(input, options) {
     const timeTokens = buildTimeTokens(input);
     const whenSequences = PRECOMPUTED_WHEN_SEQUENCES;
     const matcher = (candidate, candidateLower) => matchesPrefix(candidate, candidateLower, prefixContext);
+    const compactOralSuggestions = suggestCompactOralMealTiming(prefix, limit, matcher);
+    if (compactOralSuggestions && compactOralSuggestions.length > 0) {
+        return compactOralSuggestions;
+    }
+    if (options === null || options === void 0 ? void 0 : options.enableMealDashSyntax) {
+        const mealDashSuggestions = suggestMealDashSyntax(prefix, limit, matcher);
+        if (mealDashSuggestions && mealDashSuggestions.length > 0) {
+            return mealDashSuggestions;
+        }
+    }
     return generateCandidateDirections(pairs, doseValues, prnReasons, intervalTokens, timeTokens, whenSequences, limit, matcher);
 }

package/package.json

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