ezmedicationinput 0.1.37 → 0.1.39

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
 
@@ -346,6 +348,10 @@ You can specify the number of times (total count) the medication is supposed to
   combinations (e.g. `1x3` → breakfast/lunch/dinner). This also respects
   `context.mealRelation` when provided and only applies to schedules with four
   or fewer daily doses.
+- `enableMealDashSyntax`: when `true`, enables shorthand meal-dose patterns
+  such as `1-0-1`, `1-0-1 pc`, `10-12-0 ac`, and `1-0-0-1 ac`. The parser
+  expands them into multiple dosage clauses aligned to breakfast/lunch/dinner
+  (plus bedtime for a 4th slot).
 - `twoPerDayPair`: controls whether 2× AC/PC/C doses expand to breakfast+dinner (default) or breakfast+lunch.
 - `assumeSingleDiscreteDose`: when `true`, missing discrete doses (such as
   tablets or capsules) default to a single unit when the parser can infer a

package/dist/index.js

@@ -58,6 +58,96 @@ 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 parseMealDashValues(token) {
+    if (!/^[0-9]+(?:\.[0-9]+)?(?:-[0-9]+(?:\.[0-9]+)?){2,3}$/.test(token)) {
+        return undefined;
+    }
+    const values = token.split("-").map((part) => Number(part));
+    if (values.length !== 3 && values.length !== 4) {
+        return undefined;
+    }
+    if (!values.every((value) => Number.isFinite(value) && value >= 0)) {
+        return undefined;
+    }
+    return values;
+}
+function mealDashEvents(length, relation) {
+    const base = relation === "ac"
+        ? ["ACM", "ACD", "ACV"]
+        : relation === "pc"
+            ? ["PCM", "PCD", "PCV"]
+            : ["CM", "CD", "CV"];
+    if (length === 4) {
+        return [...base, "HS"];
+    }
+    return base;
+}
+function formatMealDashAmount(value) {
+    if (Number.isInteger(value)) {
+        return String(value);
+    }
+    return String(value).replace(/\.0+$/, "").replace(/(\.\d*?)0+$/, "$1");
+}
+function expandMealDashSegment(segment) {
+    const tokens = (0, parser_1.tokenize)(segment.text);
+    if (tokens.length === 0) {
+        return [segment];
+    }
+    const firstToken = tokens[0];
+    const values = parseMealDashValues(firstToken.lower);
+    if (!values) {
+        return [segment];
+    }
+    let relation = "meal";
+    let relationIndex = -1;
+    for (let i = 1; i < tokens.length; i += 1) {
+        const lower = tokens[i].lower.replace(/[.,;:]/g, "");
+        if (lower === "ac") {
+            relation = "ac";
+            relationIndex = i;
+            break;
+        }
+        if (lower === "pc") {
+            relation = "pc";
+            relationIndex = i;
+            break;
+        }
+    }
+    const suffixTokens = tokens
+        .filter((token, index) => index !== 0 && index !== relationIndex)
+        .map((token) => token.original);
+    const events = mealDashEvents(values.length, relation);
+    const expanded = values
+        .map((value, index) => ({ value, event: events[index] }))
+        .filter(({ value }) => value > 0)
+        .map(({ value, event }) => {
+        const text = [formatMealDashAmount(value), ...suffixTokens, event]
+            .filter((part) => part && part.trim().length > 0)
+            .join(" ")
+            .replace(/\s+/g, " ")
+            .trim();
+        return {
+            text,
+            start: segment.start,
+            end: segment.end
+        };
+    })
+        .filter((item) => item.text.length > 0);
+    if (expanded.length === 0) {
+        return [segment];
+    }
+    return expanded;
+}
+function expandMealDashSegments(segments, options) {
+    if (!(options === null || options === void 0 ? void 0 : options.enableMealDashSyntax)) {
+        return segments;
+    }
+    const expanded = [];
+    for (const segment of segments) {
+        expanded.push(...expandMealDashSegment(segment));
+    }
+    return expanded;
+}
 function toSegmentMeta(segments) {
     return segments.map((segment, index) => ({
         index,
@@ -66,7 +156,7 @@ function toSegmentMeta(segments) {
     }));
 }
 function parseSig(input, options) {
-    const segments = (0, segment_1.splitSigSegments)(input);
+    const segments = expandMealDashSegments((0, segment_1.splitSigSegments)(input), options);
     const carry = {};
     const results = [];
     for (const segment of segments) {
@@ -92,7 +182,7 @@ function parseSig(input, options) {
     };
 }
 function lintSig(input, options) {
-    const segments = (0, segment_1.splitSigSegments)(input);
+    const segments = expandMealDashSegments((0, segment_1.splitSigSegments)(input), options);
     const carry = {};
     const results = [];
     for (const segment of segments) {
@@ -132,7 +222,7 @@ function lintSig(input, options) {
 }
 function parseSigAsync(input, options) {
     return __awaiter(this, void 0, void 0, function* () {
-        const segments = (0, segment_1.splitSigSegments)(input);
+        const segments = expandMealDashSegments((0, segment_1.splitSigSegments)(input), options);
         const carry = {};
         const results = [];
         for (const segment of segments) {

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/dist/types.d.ts

@@ -457,6 +457,13 @@ export interface ParseOptions extends FormatOptions {
      * `context.mealRelation` when provided.
      */
     smartMealExpansion?: boolean;
+    /**
+     * Enables parsing meal dash shorthand like `1-0-1` / `1-0-0-1` into
+     * multiple dosage clauses aligned to breakfast/lunch/dinner/(bedtime).
+     * Optional trailing `ac` / `pc` maps meal anchors to before/after meal
+     * variants.
+     */
+    enableMealDashSyntax?: boolean;
     /**
      * Controls which meal pair is assumed for twice-daily meal expansions.
      * Defaults to "breakfast+dinner" to mirror common clinical practice.

package/package.json

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