agentfootprint 9.128.1 → 9.131.0

package/dist/core/time/resolve.js

@@ -0,0 +1,694 @@
+"use strict";
+/**
+ * core/time/resolve — parts + clock + policy → every candidate window, and
+ * the one rule for which candidate a reading settles on.
+ *
+ * Pattern: the hard, universal half of reading time, written once (time
+ *          design § 5.1): a strategy tokenizes (`reader.ts`); this module
+ *          resolves, the same way for every strategy. It is the one place
+ *          zone arithmetic meets the person's words.
+ * Role:    core/ leaf (the time layer). Imports `instant.ts`, `zone.ts`,
+ *          `range.ts`, `present.ts` (the `Grain` word), `reader.ts` (the
+ *          parts) and `resolveRecord.ts` (the shapes, the policy and the
+ *          record's checks — split out for the synchronous doors, and
+ *          re-exported here). `rowsBuild.ts` · `timeReadingRows` calls it at the
+ *          seed, which loads it only under `.time()`.
+ * Emits:   N/A.
+ *
+ * ## Every candidate, then the policy (§ 5.1, § 11)
+ *
+ * {@link resolveMention} writes EVERY reading of the parts, each tagged with
+ * how it read them ({@link ReadingTags}):
+ *
+ * | Parts | Candidates |
+ * |-------|------------|
+ * | a numeric date `10/09/26` | up to three: `MDY`, `DMY`, `YMD` — each checked as a calendar day |
+ * | a numeric date of two fields `10/09` | `MDY` and `DMY`, each for the clock's year and the one before |
+ * | a date with no year | the clock's year (`current`) and the one before (`previous`) |
+ * | a two-digit year `26` | the clock's century, noted `century-implied` |
+ * | a clock time with no meridiem, hour 1–12 (`8:40`) | am and pm |
+ * | a wall time the clocks go back through (`01:30`) | both instants, each noted `dst-overlap` |
+ * | a wall time the clocks skip (`02:30`) | both readings Temporal names, each noted `dst-gap` |
+ * | a day word (`{ day, offset: -1 }`) | the calendar day in the zone, anchored on the clock |
+ * | a span (`{ minute, count: 40 }`) | a look-back until the clock's `now` |
+ * | a range | one per combination of its sides that agree on date order and year, `from` before `to` |
+ *
+ * The fixed laws: a time is read to the END OF ITS GRAIN ("to 8:40" is
+ * `[08:00, 08:41)`, noted `end-of-grain`); a day starts at its first instant
+ * (Temporal's `startOfDay`: a midnight the clocks skip starts the day at the
+ * first wall time that exists); a zone the person did not say is the clock's;
+ * a zone they said is an IANA name or a numeric offset — any other token (an
+ * abbreviation such as `PST`) resolves nothing and is ASKED (no map ships in
+ * v1). Parts v1 does not resolve — a part of the day, a calendar span other
+ * than a day, a window anchored on the previous one — are named
+ * `unsupported`, never guessed.
+ *
+ * {@link chooseReading} then applies the app's policy (`dateOrder`, `year`)
+ * and names what is left: one window (`only`, or `policy` when the policy
+ * removed a reading — a choice nobody said, recorded), several (`open`, with
+ * the questions an ask must settle), or none. A `kind: 'model'` reader's
+ * window is never settled by the library: it stays `open` until the person
+ * confirms it (§ 5.5), and its candidates carry `said: []`. Since the
+ * owner's decision "Always confirm" (time design TQ29) neither is ANY
+ * reading the record files: `rowsBuild.ts` · `timeReadingRows` passes
+ * `confirm: true` for every reader's reading, so only the person's answer
+ * in the time ask settles a window. The `confirm` parameter's default
+ * (`kind === 'model'`) is the unit's, for a caller that resolves parts
+ * outside the record.
+ *
+ * @example
+ * ```ts
+ * const clock = { now: '2026-10-09T15:40:00Z', zone: 'America/Los_Angeles' };
+ * const rule = { id: 'fixture', kind: 'rule' as const };
+ * const res = resolveMention([{ date: { kind: 'numeric', fields: [10, 9, 26] } }], clock, rule);
+ * res.candidates.map((c) => c.reading.dateOrder); // ['MDY', 'DMY', 'YMD']
+ * chooseReading(res, DEFAULT_TIME_POLICY, 'rule');
+ * // { by: 'open', remaining: [0, 1, 2], open: ['date-order'] }
+ * chooseReading(res, { dateOrder: 'DMY', year: 'ask' }, 'rule');
+ * // { by: 'policy', candidate: 1, policy: { dateOrder: 'DMY' } }
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chooseReading = exports.resolveMention = exports.withZoneAnswered = exports.readPolicy = exports.DEFAULT_TIME_POLICY = exports.choiceIsWellFormed = exports.candidateIsWellFormed = void 0;
+const instant_js_1 = require("./instant.js");
+const range_js_1 = require("./range.js");
+const zone_js_1 = require("./zone.js");
+const resolveRecord_js_1 = require("./resolveRecord.js");
+var resolveRecord_js_2 = require("./resolveRecord.js");
+Object.defineProperty(exports, "candidateIsWellFormed", { enumerable: true, get: function () { return resolveRecord_js_2.candidateIsWellFormed; } });
+Object.defineProperty(exports, "choiceIsWellFormed", { enumerable: true, get: function () { return resolveRecord_js_2.choiceIsWellFormed; } });
+Object.defineProperty(exports, "DEFAULT_TIME_POLICY", { enumerable: true, get: function () { return resolveRecord_js_2.DEFAULT_TIME_POLICY; } });
+Object.defineProperty(exports, "readPolicy", { enumerable: true, get: function () { return resolveRecord_js_2.readPolicy; } });
+/** `±HH`, `±HHMM`, `±HH:MM` — a colon only between hours and minutes, never trailing. */
+const OFFSET_TOKEN = /^([+-])(\d{2})(?::?(\d{2}))?$/;
+function zoneOf(token, clockZone) {
+    if (token === undefined)
+        return { kind: 'iana', zone: clockZone, said: false };
+    if ((0, zone_js_1.isZoneName)(token))
+        return { kind: 'iana', zone: token, said: true };
+    if (token === 'Z')
+        return { kind: 'offset', minutes: 0, spelled: 'Z' };
+    const m = OFFSET_TOKEN.exec(token);
+    if (m !== null) {
+        const hours = Number(m[2]);
+        const minutes = m[3] === undefined ? 0 : Number(m[3]);
+        if (hours <= 23 && minutes <= 59) {
+            const total = (m[1] === '-' ? -1 : 1) * (hours * 60 + minutes);
+            const spelled = `${m[1]}${m[2]}:${m[3] ?? '00'}`;
+            return { kind: 'offset', minutes: total === 0 ? 0 : total, spelled };
+        }
+    }
+    return { kind: 'unknown' };
+}
+/**
+ * The parts with every zone token this layer cannot read (an abbreviation such
+ * as `PST`) replaced by the zone the PERSON named when asked (§ 6.3) — the
+ * whole mention's and each range side's. A token it can read is kept.
+ *
+ * @example
+ * ```ts
+ * withZoneAnswered([{ wall: { h: 8, meridiem: 'am' }, zoneToken: 'PST' }], 'America/Los_Angeles');
+ * // [{ wall: { h: 8, meridiem: 'am' }, zoneToken: 'America/Los_Angeles' }]
+ * ```
+ */
+function withZoneAnswered(parses, zone) {
+    const fix = (parts) => parts.zoneToken !== undefined && zoneOf(parts.zoneToken, zone).kind === 'unknown'
+        ? { ...parts, zoneToken: zone }
+        : parts;
+    return parses.map((parts) => {
+        const outer = fix(parts);
+        return outer.rangeOf === undefined
+            ? outer
+            : { ...outer, rangeOf: [fix(outer.rangeOf[0]), fix(outer.rangeOf[1])] };
+    });
+}
+exports.withZoneAnswered = withZoneAnswered;
+/** The wall time an instant shows under a zone read. */
+function wallIn(zone, ms) {
+    if (zone.kind === 'iana')
+        return (0, zone_js_1.wallAt)(zone.zone, ms);
+    const d = new Date(ms + (zone.kind === 'offset' ? zone.minutes : 0) * 60_000);
+    return {
+        year: d.getUTCFullYear(),
+        month: d.getUTCMonth() + 1,
+        day: d.getUTCDate(),
+        hour: d.getUTCHours(),
+        minute: d.getUTCMinutes(),
+    };
+}
+/** The offset to spell an instant in, minutes east of UTC. */
+function offsetFor(zone, ms) {
+    return zone.kind === 'offset' ? zone.minutes : (0, zone_js_1.offsetAt)(zone.zone, ms);
+}
+/** Every instant a wall time names under a zone read (two in a DST overlap or gap). */
+function instantsOf(wall, zone) {
+    if (!(0, zone_js_1.isWallTime)(wall))
+        return [];
+    const utc = (0, instant_js_1.utcWallMs)(wall.year, wall.month, wall.day, wall.hour, wall.minute, wall.second ?? 0);
+    if (zone.kind === 'offset')
+        return [{ ms: utc - zone.minutes * 60_000 }];
+    if (zone.kind !== 'iana')
+        return [];
+    const reading = (0, zone_js_1.readWall)(wall, zone.zone);
+    if (reading.kind === 'unique')
+        return [{ ms: reading.ms }];
+    const kind = reading.kind === 'overlap' ? 'dst-overlap' : 'dst-gap';
+    return [
+        { ms: reading.earlier, dst: { kind, which: 'earlier' } },
+        { ms: reading.later, dst: { kind, which: 'later' } },
+    ];
+}
+/** The first instant of a calendar day in a zone (Temporal's `startOfDay`). */
+function dayStart(y, m, d, zone) {
+    const wall = { year: y, month: m, day: d, hour: 0, minute: 0 };
+    if (!(0, zone_js_1.isWallTime)(wall))
+        return undefined;
+    if (zone.kind === 'offset')
+        return (0, instant_js_1.utcWallMs)(y, m, d, 0, 0, 0) - zone.minutes * 60_000;
+    if (zone.kind !== 'iana')
+        return undefined;
+    return (0, zone_js_1.wallToInstant)(wall, zone.zone, 'compatible');
+}
+/** The calendar day `days` after `y-m-d`. */
+function addDays(y, m, d, days) {
+    const date = new Date((0, instant_js_1.utcWallMs)(y, m, d + days, 0, 0, 0));
+    return [date.getUTCFullYear(), date.getUTCMonth() + 1, date.getUTCDate()];
+}
+const isDay = (y, m, d) => Number.isInteger(y) &&
+    y >= 0 &&
+    y <= 9999 &&
+    m >= 1 &&
+    m <= 12 &&
+    d >= 1 &&
+    d <= (0, instant_js_1.daysInMonth)(y, m);
+/** A said year value → a full year, or `undefined`; `century` set when the clock's century was used. */
+function fullYear(value, digits, clockYear) {
+    const century = Math.floor(clockYear / 100) * 100;
+    if (digits === 2)
+        return value <= 99 ? { year: century + value, century } : undefined;
+    if (digits === 4)
+        return value >= 1000 ? { year: value } : undefined;
+    return value >= 100 ? { year: value } : { year: century + value, century };
+}
+/** The readings of a date said without a year: the clock's year, and the one before. */
+function yearless(m, d, clockYear, tags) {
+    const out = [];
+    for (const [year, which] of [
+        [clockYear, 'current'],
+        [clockYear - 1, 'previous'],
+    ]) {
+        if (!isDay(year, m, d))
+            continue;
+        out.push({
+            y: year,
+            m,
+            d,
+            tags: { ...tags, year: which },
+            said: ['month', 'day'],
+            implied: ['year'],
+            notes: [],
+            anchor: 'none',
+        });
+    }
+    return out;
+}
+const ORDERS3 = [
+    // [tag, index of month, index of day, index of year]
+    ['MDY', 0, 1, 2],
+    ['DMY', 1, 0, 2],
+    ['YMD', 1, 2, 0],
+];
+function numericDates(fields, digits, clockYear) {
+    const out = [];
+    if (fields.length === 2) {
+        const [a, b] = fields;
+        out.push(...yearless(a, b, clockYear, { dateOrder: 'MDY' }));
+        out.push(...yearless(b, a, clockYear, { dateOrder: 'DMY' }));
+        return out;
+    }
+    for (const [tag, mi, di, yi] of ORDERS3) {
+        const full = fullYear(fields[yi], digits, clockYear);
+        if (full === undefined)
+            continue;
+        const m = fields[mi];
+        const d = fields[di];
+        if (!isDay(full.year, m, d))
+            continue;
+        out.push({
+            y: full.year,
+            m,
+            d,
+            tags: { dateOrder: tag, year: 'said' },
+            said: ['year', 'month', 'day'],
+            implied: [],
+            notes: full.century !== undefined ? [{ kind: 'century-implied', century: full.century }] : [],
+            anchor: 'none',
+        });
+    }
+    return out;
+}
+/** Every date reading of the parts, or a part v1 does not resolve. */
+function datesOf(parts, today) {
+    const rel = parts.relative;
+    if (rel !== undefined) {
+        if (parts.date !== undefined)
+            return { unsupported: 'a date and a relative day together' };
+        if (!('offset' in rel) || rel.unit !== 'day') {
+            return { unsupported: `relative ${rel.unit}` };
+        }
+        const [y, m, d] = addDays(today.year, today.month, today.day, rel.offset);
+        return [
+            {
+                y,
+                m,
+                d,
+                tags: {},
+                said: ['day'],
+                implied: ['year', 'month'],
+                notes: [],
+                anchor: 'message',
+            },
+        ];
+    }
+    const date = parts.date;
+    if (date === undefined) {
+        if (parts.wall === undefined)
+            return { unsupported: 'no date or time' };
+        // A clock time alone is on the clock's day.
+        return [
+            {
+                y: today.year,
+                m: today.month,
+                d: today.day,
+                tags: {},
+                said: [],
+                implied: ['year', 'month', 'day'],
+                notes: [],
+                anchor: 'message',
+            },
+        ];
+    }
+    if (date.kind === 'numeric')
+        return numericDates(date.fields, date.yearDigits, today.year);
+    if (date.year === undefined)
+        return yearless(date.month, date.day, today.year, {});
+    if (!isDay(date.year, date.month, date.day))
+        return [];
+    return [
+        {
+            y: date.year,
+            m: date.month,
+            d: date.day,
+            tags: { year: 'said' },
+            said: ['year', 'month', 'day'],
+            implied: [],
+            notes: [],
+            anchor: 'none',
+        },
+    ];
+}
+// ─── Clock times ─────────────────────────────────────────────────────────
+/** The 24-hour readings of a clock time: one, or am and pm when no meridiem settles an hour 1–12. */
+function hoursOf(wall) {
+    if (wall.meridiem !== undefined) {
+        if (wall.h < 1 || wall.h > 12)
+            return [];
+        return [{ h: (wall.h % 12) + (wall.meridiem === 'pm' ? 12 : 0) }];
+    }
+    if (wall.h >= 1 && wall.h <= 12) {
+        return [
+            { h: wall.h % 12, meridiem: 'am' },
+            { h: (wall.h % 12) + 12, meridiem: 'pm' },
+        ];
+    }
+    return [{ h: wall.h }];
+}
+const GRAIN_MS = {
+    hour: 3_600_000,
+    minute: 60_000,
+    second: 1_000,
+};
+function pointsOf(parts, clock, nowMs) {
+    if (parts.partOfDay !== undefined)
+        return { unsupported: 'a part of the day' };
+    if (parts.anchor !== undefined)
+        return { unsupported: 'a window anchored on the previous one' };
+    const zone = zoneOf(parts.zoneToken, clock.zone);
+    if (zone.kind === 'unknown')
+        return { needsZone: true };
+    const dates = datesOf(parts, wallIn(zone, nowMs));
+    if (!Array.isArray(dates))
+        return dates;
+    const zoneSaid = parts.zoneToken !== undefined ? ['zone'] : [];
+    const zoneImplied = parts.zoneToken !== undefined ? [] : ['zone'];
+    const offsetNote = zone.kind === 'offset' ? [{ kind: 'offset-said', offset: zone.spelled }] : [];
+    const out = [];
+    for (const date of dates) {
+        const base = {
+            zone,
+            said: [...date.said, ...zoneSaid],
+            implied: [...date.implied, ...zoneImplied],
+            anchor: date.anchor,
+        };
+        const wall = parts.wall;
+        if (wall === undefined) {
+            const from = dayStart(date.y, date.m, date.d, zone);
+            const [ny, nm, nd] = addDays(date.y, date.m, date.d, 1);
+            const to = dayStart(ny, nm, nd, zone);
+            if (from === undefined || to === undefined)
+                continue;
+            out.push({
+                ...base,
+                fromMs: from,
+                toMs: to,
+                grain: 'day',
+                tags: date.tags,
+                notes: [...date.notes, ...offsetNote],
+            });
+            continue;
+        }
+        const grain = wall.s !== undefined ? 'second' : wall.m !== undefined ? 'minute' : 'hour';
+        const wallSaid = [
+            'hour',
+            ...(wall.m !== undefined ? ['minute'] : []),
+            ...(wall.s !== undefined ? ['second'] : []),
+            ...(wall.meridiem !== undefined ? ['meridiem'] : []),
+        ];
+        for (const hour of hoursOf(wall)) {
+            const at = {
+                year: date.y,
+                month: date.m,
+                day: date.d,
+                hour: hour.h,
+                minute: wall.m ?? 0,
+                second: wall.s ?? 0,
+            };
+            for (const instant of instantsOf(at, zone)) {
+                out.push({
+                    ...base,
+                    said: [...base.said, ...wallSaid],
+                    fromMs: instant.ms,
+                    toMs: instant.ms + GRAIN_MS[grain],
+                    grain,
+                    tags: { ...date.tags, ...(hour.meridiem !== undefined && { meridiem: hour.meridiem }) },
+                    notes: [...date.notes, ...offsetNote],
+                    ...(instant.dst !== undefined && { dst: instant.dst }),
+                });
+            }
+        }
+    }
+    return out;
+}
+// ─── Candidates ──────────────────────────────────────────────────────────
+const GRAIN_ORDER = ['year', 'month', 'week', 'day', 'hour', 'minute', 'second'];
+const finer = (a, b) => GRAIN_ORDER.indexOf(a) >= GRAIN_ORDER.indexOf(b) ? a : b;
+const partsIn = (parts) => resolveRecord_js_1.PART_ORDER.filter((p) => parts.includes(p));
+function noteKey(note) {
+    return JSON.stringify(note);
+}
+function uniqueNotes(notes) {
+    const seen = new Set();
+    return notes.filter((n) => {
+        const key = noteKey(n);
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+function dstNote(dst, end) {
+    if (dst === undefined)
+        return [];
+    return [{ kind: dst.kind, which: dst.which, ...(end !== undefined && { end }) }];
+}
+function spell(ms, zone) {
+    return (0, instant_js_1.spellInstant)({ ms, nanos: 0 }, offsetFor(zone, ms));
+}
+function windowZone(zone, clock) {
+    return zone.kind === 'iana' ? zone.zone : clock.zone;
+}
+function fromPoint(point, clock) {
+    const from = spell(point.fromMs, point.zone);
+    const to = spell(point.toMs, point.zone);
+    if (from === undefined || to === undefined)
+        return undefined;
+    const range = { from, to };
+    return {
+        said: point.said,
+        candidate: {
+            window: { kind: 'range', range },
+            range,
+            zone: windowZone(point.zone, clock),
+            grain: point.grain,
+            implied: partsIn(point.implied),
+            anchor: point.anchor,
+            notes: uniqueNotes([...point.notes, ...dstNote(point.dst), { kind: 'end-of-grain' }]),
+            reading: point.tags,
+        },
+    };
+}
+function agrees(a, b) {
+    const same = (x, y) => x === undefined || y === undefined || x === y;
+    return same(a.dateOrder, b.dateOrder) && same(a.year, b.year);
+}
+function fromSides(l, r, clock) {
+    if (!agrees(l.tags, r.tags) || !(l.fromMs < r.toMs))
+        return undefined;
+    const from = spell(l.fromMs, l.zone);
+    const to = spell(r.toMs, r.zone);
+    if (from === undefined || to === undefined)
+        return undefined;
+    const range = { from, to };
+    const tags = {
+        ...((l.tags.dateOrder ?? r.tags.dateOrder) !== undefined && {
+            dateOrder: l.tags.dateOrder ?? r.tags.dateOrder,
+        }),
+        ...(l.tags.meridiem !== undefined && { meridiem: l.tags.meridiem }),
+        ...(r.tags.meridiem !== undefined && { endMeridiem: r.tags.meridiem }),
+        ...((l.tags.year ?? r.tags.year) !== undefined && { year: l.tags.year ?? r.tags.year }),
+    };
+    return {
+        said: [...l.said, ...r.said],
+        candidate: {
+            window: { kind: 'range', range },
+            range,
+            zone: windowZone(l.zone, clock),
+            grain: finer(l.grain, r.grain),
+            implied: partsIn([...l.implied, ...r.implied]),
+            anchor: l.anchor === 'message' || r.anchor === 'message' ? 'message' : 'none',
+            notes: uniqueNotes([
+                ...l.notes,
+                ...r.notes,
+                ...dstNote(l.dst, 'from'),
+                ...dstNote(r.dst, 'to'),
+                { kind: 'end-of-grain' },
+            ]),
+            reading: tags,
+        },
+    };
+}
+const LOOKBACK_LETTER = {
+    second: 's',
+    minute: 'm',
+    hour: 'h',
+    day: 'd',
+    week: 'w',
+};
+function lookbackBuilt(parts, clock) {
+    const rel = parts.relative;
+    if (rel === undefined || !('count' in rel))
+        return undefined;
+    const others = Object.keys(parts).filter((k) => k !== 'relative');
+    if (others.length > 0)
+        return { unsupported: 'a look-back with other parts' };
+    const duration = `${rel.count}${LOOKBACK_LETTER[rel.unit]}`;
+    let range;
+    try {
+        range = (0, range_js_1.lookbackRange)(clock.now, duration, 'smhdw');
+    }
+    catch {
+        return { unsupported: 'a look-back past the calendar' };
+    }
+    return {
+        said: ['duration'],
+        candidate: {
+            window: { kind: 'lookback', duration },
+            range,
+            zone: clock.zone,
+            grain: rel.unit,
+            implied: [],
+            anchor: 'message',
+            notes: [],
+            reading: {},
+        },
+    };
+}
+/** A range side with what it takes from the whole mention and the other side: the day, the zone. */
+function sideOf(side, outer, other) {
+    const hasDay = (p) => p.date !== undefined || p.relative !== undefined;
+    const day = hasDay(side) ? side : hasDay(outer) ? outer : hasDay(other) ? other : undefined;
+    const zoneToken = side.zoneToken ?? outer.zoneToken ?? other.zoneToken;
+    return {
+        ...(side.wall !== undefined && { wall: side.wall }),
+        ...(side.partOfDay !== undefined && { partOfDay: side.partOfDay }),
+        ...(side.anchor !== undefined && { anchor: side.anchor }),
+        ...(day?.date !== undefined && { date: day.date }),
+        ...(day?.relative !== undefined && { relative: day.relative }),
+        ...(zoneToken !== undefined && { zoneToken }),
+    };
+}
+function builtOf(parts, clock, nowMs) {
+    const lookback = lookbackBuilt(parts, clock);
+    if (lookback !== undefined)
+        return 'candidate' in lookback ? [lookback] : lookback;
+    if (parts.rangeOf === undefined) {
+        const points = pointsOf(parts, clock, nowMs);
+        if (!Array.isArray(points))
+            return points;
+        return points.map((p) => fromPoint(p, clock)).filter((b) => b !== undefined);
+    }
+    if (parts.wall !== undefined || parts.partOfDay !== undefined || parts.anchor !== undefined) {
+        return { unsupported: 'a range with a time outside its two sides' };
+    }
+    const [l, r] = parts.rangeOf;
+    const left = sideOf(l, parts, r);
+    const right = sideOf(r, parts, l);
+    if (lookbackBuilt(left, clock) !== undefined || lookbackBuilt(right, clock) !== undefined) {
+        return { unsupported: 'a look-back as a range side' };
+    }
+    const lp = pointsOf(left, clock, nowMs);
+    if (!Array.isArray(lp))
+        return lp;
+    const rp = pointsOf(right, clock, nowMs);
+    if (!Array.isArray(rp))
+        return rp;
+    const out = [];
+    for (const a of lp) {
+        for (const b of rp) {
+            const built = fromSides(a, b, clock);
+            if (built !== undefined)
+                out.push(built);
+        }
+    }
+    return out;
+}
+/**
+ * Every candidate window of one mention's parses, resolved against the
+ * clock. A reading the person must confirm (`confirm: true` — every reading
+ * the record files, TQ29; a `model` reader's by default) carries `said: []`.
+ */
+function resolveMention(parses, clock, reader, confirm = reader.kind === 'model') {
+    const now = (0, instant_js_1.instantOf)(clock.now, 'strict');
+    if (now === undefined || !(0, zone_js_1.isZoneName)(clock.zone)) {
+        throw new TypeError('resolveMention: the clock must carry a strict instant and an IANA zone name.');
+    }
+    const candidates = [];
+    const unsupported = [];
+    let needsZone = false;
+    parses.forEach((parts, parse) => {
+        const built = builtOf(parts, clock, now.ms);
+        if (!Array.isArray(built)) {
+            if ('needsZone' in built)
+                needsZone = true;
+            else
+                unsupported.push(built.unsupported);
+            return;
+        }
+        for (const b of built) {
+            if (!(0, range_js_1.isTimeRange)(b.candidate.range))
+                continue;
+            candidates.push({
+                ...b.candidate,
+                said: confirm ? [] : partsIn(b.said),
+                reader: { id: reader.id, kind: reader.kind },
+                parse,
+            });
+        }
+    });
+    return { candidates, needsZone, unsupported };
+}
+exports.resolveMention = resolveMention;
+// ─── Choosing ────────────────────────────────────────────────────────────
+const windowKey = (c) => c.window.kind === 'lookback' ? `lookback:${c.window.duration}` : `${c.range.from}/${c.range.to}`;
+function openQuestions(candidates, confirm) {
+    const differs = (read) => new Set(candidates.map((c) => JSON.stringify(read(c) ?? null))).size > 1;
+    const open = [];
+    if (differs((c) => c.parse))
+        open.push('parse');
+    if (differs((c) => c.reading.dateOrder))
+        open.push('date-order');
+    if (differs((c) => c.reading.year))
+        open.push('year');
+    if (differs((c) => [c.reading.meridiem, c.reading.endMeridiem]))
+        open.push('meridiem');
+    if (differs((c) => c.notes.filter((n) => n.kind === 'dst-overlap' || n.kind === 'dst-gap'))) {
+        open.push('dst');
+    }
+    if (confirm)
+        open.push('confirm');
+    return open;
+}
+/**
+ * Whether a policy step DECIDED something: it removed a reading whose window
+ * none of the kept readings names. A step that removed only same-window
+ * readings (`12/12/12` under `DMY` — every order names one day) changed
+ * nothing the person would see, so the choice is not recorded as assumed.
+ */
+function policyDecided(all, before, kept) {
+    if (kept.length === before.length)
+        return false;
+    const keptWindows = new Set(kept.map((i) => windowKey(all[i])));
+    return before.some((i) => !kept.includes(i) && !keptWindows.has(windowKey(all[i])));
+}
+/**
+ * How one mention settles under the app's policy (§ 5.1, § 11). The policy
+ * only removes readings; it never adds one. A DST choice, a meridiem, a
+ * zone the person named that is no zone, and a reading to confirm
+ * (`confirm` — every reading the record files, TQ29) are never settled here
+ * — they stay `open` for the person.
+ */
+function chooseReading(resolution, policy, kind, problem, confirm = kind === 'model') {
+    if (problem === 'unreadable')
+        return { by: 'none', why: 'unreadable' };
+    if (resolution.needsZone && resolution.candidates.length === 0) {
+        return { by: 'open', remaining: [], open: ['zone'] };
+    }
+    const all = resolution.candidates;
+    if (all.length === 0) {
+        return { by: 'none', why: resolution.unsupported.length > 0 ? 'unsupported' : 'no-candidate' };
+    }
+    const applied = {};
+    let remaining = all.map((_, i) => i);
+    if (policy.dateOrder !== 'ask') {
+        const kept = remaining.filter((i) => {
+            const order = all[i]?.reading.dateOrder;
+            return order === undefined || order === policy.dateOrder;
+        });
+        if (policyDecided(all, remaining, kept))
+            applied.dateOrder = policy.dateOrder;
+        remaining = kept;
+    }
+    if (policy.year !== 'ask') {
+        const kept = remaining.filter((i) => all[i]?.reading.year !== 'previous');
+        if (policyDecided(all, remaining, kept))
+            applied.year = policy.year;
+        remaining = kept;
+    }
+    if (remaining.length === 0)
+        return { by: 'none', why: 'excluded-by-policy' };
+    const usedPolicy = Object.keys(applied).length > 0;
+    const left = remaining.map((i) => all[i]);
+    const windows = new Set(left.map(windowKey));
+    const zoneOpen = resolution.needsZone ? ['zone'] : [];
+    if (windows.size === 1 && zoneOpen.length === 0) {
+        const candidate = remaining[0];
+        if (confirm) {
+            return { by: 'open', remaining, open: ['confirm'], ...(usedPolicy && { policy: applied }) };
+        }
+        return usedPolicy ? { by: 'policy', candidate, policy: applied } : { by: 'only', candidate };
+    }
+    const open = [...zoneOpen, ...openQuestions(left, confirm)];
+    return { by: 'open', remaining, open, ...(usedPolicy && { policy: applied }) };
+}
+exports.chooseReading = chooseReading;
+//# sourceMappingURL=resolve.js.map