agentfootprint 9.128.1 → 9.131.0

package/dist/types/core/time/reader.d.ts

@@ -0,0 +1,163 @@
+/**
+ * core/time/reader — the port a strategy reads a person's words through, and
+ * the checks every reading passes before anything resolves it.
+ *
+ * Pattern: port + adapter (Duckling's value/resolution split). A strategy
+ *          TOKENIZES: it returns the parts it sees and the verbatim quote,
+ *          never an instant, never a date order, never a zone. Everything
+ *          that turns parts into instants is `resolve.ts`'s, the same way for
+ *          every strategy (time design § 5.1).
+ * Role:    core/ leaf (the time layer). Imports nothing. The builder's
+ *          `.time({ reader })` checks a reader through {@link readerIssue};
+ *          seed checks what it returned through {@link checkReading}.
+ * Emits:   N/A.
+ *
+ * ## What is checked — shape, never meaning
+ *
+ * | Check | A failure |
+ * |-------|-----------|
+ * | the reader: `id`, `version`, `locale` non-empty strings, `kind` `'rule'` or `'model'`, `read` a function | refused at build |
+ * | the reading: `{ mentions: [] }`, at most {@link MAX_MENTIONS} | the reader broke its port — the run fails, naming it |
+ * | each mention's `quote`: a non-empty VERBATIM substring of the text read | the mention is refused (`quote-not-in-text`) and keeps no text |
+ * | each mention's parts: the {@link TimeParts} shape, every field in range, no unknown key, at most {@link MAX_PARSES} | the mention is refused (`malformed`) |
+ *
+ * None of these checks what a word MEANS: a model that reads "yesterday" as
+ * the wrong day passes every one of them. That is why NO reading is ever the
+ * person's words — a `rule` reading as much as a `model` one (the owner's
+ * decision "Always confirm", time design TQ29): a reading only PROPOSES a
+ * window, offered through the time ask with its zone, and only what the
+ * person picks or types in that form is theirs (`rowsBuild.ts` ·
+ * `timeReadingRows`).
+ *
+ * @example
+ * ```ts
+ * const fixture: TimeReader = {
+ *   id: 'fixture', version: '1.0.0', locale: 'en-US', kind: 'rule',
+ *   read: () => ({ mentions: [{ quote: '10/09/26', parses: [{ date: { kind: 'numeric', fields: [10, 9, 26] } }] }] }),
+ * };
+ * readerIssue(fixture); // undefined — a well-formed reader
+ * checkReading('errors on 10/09/26', fixture.read('', { locale: 'en-US' }), 'fixture');
+ * // [{ quote: '10/09/26', parses: [{ date: { kind: 'numeric', fields: [10, 9, 26] } }] }]
+ * ```
+ */
+/** What a reader is told besides the text: a hint for its tokenizer — no clock, no zone, no map. */
+export interface TimeReadContext {
+    readonly locale: string;
+}
+/**
+ * A strategy that reads a person's words into zone-less PARTS (time design
+ * § 5.1). Armed with `.time({ reader })`; there is no default. It runs once
+ * per turn, at the seed, on the message a person wrote, and never again for
+ * that message — a resume and a retry read the recorded reading.
+ *
+ * @example
+ * ```ts
+ * const reader: TimeReader = {
+ *   id: 'my-app/english', version: '1.2.0', locale: 'en-US', kind: 'rule',
+ *   read: (text) => ({ mentions: tokenize(text) }),
+ * };
+ * Agent.create({ provider, model }).time({ zone: 'UTC', reader }).build();
+ * ```
+ */
+export interface TimeReader {
+    /** Recorded on every reading with the version, e.g. `'agentfootprint/english'`. */
+    readonly id: string;
+    readonly version: string;
+    /** The language it reads, e.g. `'en-US'`. */
+    readonly locale: string;
+    /**
+     * `'rule'`: deterministic over the text. `'model'`: an LLM or other learned
+     * reader. Neither kind's reading is ever the person's words: a `rule`
+     * reading is offered through the time ask to confirm; a `model` reading
+     * fills as a reading (`derived-from-reading`) until the person confirms it.
+     */
+    readonly kind: 'rule' | 'model';
+    read(text: string, context: TimeReadContext): TimeReading | Promise<TimeReading>;
+}
+/** What a reader returns: every time mention it found, in the order the text wrote them. */
+export interface TimeReading {
+    readonly mentions: readonly TimeMention[];
+}
+/** One mention of a time in the text. */
+export interface TimeMention {
+    /** A VERBATIM substring of the text — the library checks it. */
+    readonly quote: string;
+    /** Usually one; more only when the TOKENS split two ways. Empty when `problem` is set. */
+    readonly parses: readonly TimeParts[];
+    /** The reader saw a time here and could not read it. */
+    readonly problem?: 'unreadable';
+}
+/** A date as the text wrote it. */
+export type TimeDate = 
+/** `'10/09/26'` → `fields: [10, 9, 26]` — the ORDER is not decided by the reader. Two or three fields. */
+{
+    readonly kind: 'numeric';
+    readonly fields: readonly number[];
+    readonly yearDigits?: 2 | 4;
+}
+/** ISO or a named month: the text fixes the order. */
+ | {
+    readonly kind: 'fixed';
+    readonly year?: number;
+    readonly month: number;
+    readonly day: number;
+};
+/** A wall-clock time as the text wrote it — no zone. */
+export interface TimeWall {
+    readonly h: number;
+    readonly m?: number;
+    readonly s?: number;
+    readonly meridiem?: 'am' | 'pm';
+}
+/** A time said relative to the message's moment. */
+export type TimeRelative = 
+/** `'yesterday'` = `{ unit: 'day', offset: -1 }`. */
+{
+    readonly unit: 'minute' | 'hour' | 'day' | 'week' | 'month' | 'year';
+    readonly offset: number;
+}
+/** `'last 40 minutes'` = `{ unit: 'minute', count: 40 }` — a look-back. */
+ | {
+    readonly unit: 'second' | 'minute' | 'hour' | 'day' | 'week';
+    readonly count: number;
+};
+/** Zone-less parts, in the order the text wrote them. Every field present was said. */
+export interface TimeParts {
+    readonly date?: TimeDate;
+    readonly wall?: TimeWall;
+    /** As written: `'PST'`, `'-07:00'`, `'America/Los_Angeles'` — `resolve.ts` maps it. */
+    readonly zoneToken?: string;
+    readonly relative?: TimeRelative;
+    /** `'morning'` — a KEY into a table, never hours. */
+    readonly partOfDay?: string;
+    /** `'the hour before that'` — resolved from the recorded previous window only. */
+    readonly anchor?: 'previous';
+    /** `'8 AM to 8:40 AM'`. */
+    readonly rangeOf?: readonly [TimeParts, TimeParts];
+}
+/** The most mentions one reading may hold — a bound on the record, not a guess at language. */
+export declare const MAX_MENTIONS = 16;
+/** The most parses one mention may hold. */
+export declare const MAX_PARSES = 4;
+/** Why `value` is not a {@link TimeReader}, or `undefined` when it is one. */
+export declare function readerIssue(value: unknown): string | undefined;
+/** Why one mention was refused. A refused mention keeps no text: its quote is not the person's words. */
+export type MentionRefusal = 'quote-not-in-text' | 'malformed';
+/** One mention after the checks. */
+export type CheckedMention = {
+    readonly quote: string;
+    readonly parses: readonly TimeParts[];
+    readonly problem?: 'unreadable';
+} | {
+    readonly refused: MentionRefusal;
+};
+/** Whether `value` is a well-formed {@link TimeParts} — `nested` refuses a range inside a range side. */
+export declare function isTimeParts(value: unknown, nested?: boolean): value is TimeParts;
+/**
+ * A reader's answer for `text`, checked: one {@link CheckedMention} per
+ * mention, in order. Throws a `TypeError` naming the reader when the answer
+ * is not `{ mentions: [] }` (at most {@link MAX_MENTIONS}) — the reader
+ * broke its port, and a run is never read by a guess at what it meant.
+ */
+export declare function checkReading(text: string, value: unknown, readerId: string): CheckedMention[];
+//# sourceMappingURL=reader.d.ts.map

package/dist/types/core/time/reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reader.d.ts","sourceRoot":"","sources":["../../../../src/core/time/reader.ts"],"names":[],"mappings":"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"}

package/dist/types/core/time/readers/english.d.ts

@@ -0,0 +1,100 @@
+/**
+ * core/time/readers/english — the library's careful English reader (time
+ * design § 5.3): a tokenizer over a small, closed set of phrases, and
+ * "unreadable" for every other time phrase it recognises.
+ *
+ * Pattern: Strategy behind the `TimeReader` port (`../reader.ts`). It
+ *          TOKENIZES only: it returns the parts it sees and the verbatim
+ *          quote. It never resolves an instant, never applies a date order,
+ *          never maps a zone abbreviation and never refuses a future date —
+ *          all of that is `resolve.ts`'s, the policy's or the ask's.
+ * Role:    core/ leaf (the time layer). Imports only the port's types. Armed
+ *          by the app: `.time({ reader: englishTimeReader() })` — there is no
+ *          default reader.
+ * Emits:   N/A.
+ *
+ * ## What it reads (the v1 rows of § 5.3)
+ *
+ * | Phrase | Example | Parts |
+ * |--------|---------|-------|
+ * | an ISO date or instant | `2026-10-09`, `2026-10-09T08:00-07:00` | `date: fixed`, `wall`, `zoneToken` |
+ * | a numeric date | `10/09/26`, `10/9` | `date: numeric` — the ORDER is not decided here |
+ * | a clock time | `8 AM`, `8:40`, `20:40`, `8:40 p.m.` | `wall` (a bare `8` is a time only as a range's first side: `8 to 9 AM`) |
+ * | a range between two of the above | `8 AM to 8:40 AM`, `08:00–08:40`, `between 8 and 9 AM` | `rangeOf` (a day or zone said once for both sides is the whole mention's) |
+ * | a zone after a time or date | `America/Los_Angeles`, `UTC-07:00`, `PST` | `zoneToken`, as written (an abbreviation is ASKED — v1 ships no map) |
+ * | a day word | today, yesterday, tomorrow | `relative: { unit: 'day', offset }` |
+ * | a relative span from now | last 40 minutes, past 2 hours, the last hour, the past week | `relative: { unit, count }` — a look-back in minutes, hours, days or weeks |
+ *
+ * ## What it says "unreadable" for — never a partial reading
+ *
+ * Parts of the day (`yesterday morning`, `tonight`, `noon`), calendar spans
+ * (`last week`, `this month`), week days and named months (`Friday`,
+ * `Oct 9`), `N hours ago`, spans in words (`last two hours`), in a unit it
+ * does not read (`last 30 seconds`, `last 3 months`) or said with `previous`
+ * (`previous 7 days` — often relative to another window), a look-ahead (`next 2 hours`), an
+ * ordinal day (`the 9th`), `8 o'clock`, and any v1 phrase a modifier changes
+ * (`since 8 AM`, `before yesterday`, `around 8:40`, `earlier today`,
+ * `8 AM to now`, `past 8 PM`, `8 AM-ish`, `from 3 PM yesterday` with no `to`) and
+ * a meridiem the number contradicts (`13:00 PM`). Such a phrase is ONE mention
+ * with `problem: 'unreadable'`, quoting the whole phrase: reading `yesterday`
+ * out of `yesterday morning` would silently widen what the person said.
+ *
+ * ## It only PROPOSES — the person confirms (the owner's decision "Always confirm")
+ *
+ * Nothing this reader reads is ever filed as the person's words. Seven review
+ * rounds each found the next English spelling a word list, an allow-list or a
+ * position rule missed (a zone named in words, a look-back tied to an event,
+ * an open end, a half-read range), so the owner decided (2026-09-30, time
+ * design TQ29): every reading of a chat message is a PROPOSAL, offered
+ * through the time ask pre-filled and editable, with its window AND its zone
+ * ("I read “last 2 hours” as … in America/Los_Angeles — is that right?").
+ * Only what the person picks or types in that form is theirs. The library
+ * owns the law (`../rowsBuild.ts` · `timeReadingRows`), so this reader returns
+ * parts and quotes only — no confirm flag, no leftover list, no allow-list.
+ * A form may later skip the click only when a registered benchmark shows it
+ * is always read right (TQ29's growth rule).
+ *
+ * A numeric date the tokens could split two ways stays ONE parse — `10/09/26`
+ * is three numbers; which is the month is the policy's or the person's.
+ *
+ * @example
+ * ```ts
+ * const reader = englishTimeReader();
+ * reader.read('errors on 10/09/26 8 AM to 8:40 AM PST', { locale: 'en-US' });
+ * // { mentions: [{ quote: '10/09/26 8 AM to 8:40 AM PST', parses: [{
+ * //   date: { kind: 'numeric', fields: [10, 9, 26], yearDigits: 2 }, zoneToken: 'PST',
+ * //   rangeOf: [{ wall: { h: 8, meridiem: 'am' } }, { wall: { h: 8, m: 40, meridiem: 'am' } }] }] }] }
+ * reader.read('errors in the last 2 hours', { locale: 'en-US' });
+ * // { mentions: [{ quote: 'last 2 hours', parses: [{ relative: { unit: 'hour', count: 2 } }] }] }
+ * reader.read('what failed yesterday morning?', { locale: 'en-US' });
+ * // { mentions: [{ quote: 'yesterday morning', parses: [], problem: 'unreadable' }] }
+ * ```
+ */
+import { type TimeReader } from '../reader.js';
+/** The reader's recorded identity — on every `time-reading` row with its version. */
+export declare const ENGLISH_TIME_READER_ID = "agentfootprint/english";
+/** Raised whenever what the reader returns for some text changes. */
+export declare const ENGLISH_TIME_READER_VERSION = "1.0.0";
+/** Options for {@link englishTimeReader}. */
+export interface EnglishTimeReaderOptions {
+    /**
+     * The language tag the time ask's labels are rendered in (`present.ts`),
+     * e.g. `'en-GB'`. Default `'en-US'`. It never decides a date order — that is
+     * the policy's (`dateOrder`) or the person's.
+     */
+    readonly locale?: string;
+}
+/**
+ * The library's careful English reader: a `kind: 'rule'` tokenizer over the
+ * v1 phrases of the time design's § 5.3, "unreadable" for every other time
+ * phrase it recognises. No dependency; deterministic over the text.
+ *
+ * @example
+ * ```ts
+ * Agent.create({ provider, model })
+ *   .time({ zone: 'America/Los_Angeles', reader: englishTimeReader() })
+ *   .build();
+ * ```
+ */
+export declare function englishTimeReader(options?: EnglishTimeReaderOptions): TimeReader;
+//# sourceMappingURL=english.d.ts.map

package/dist/types/core/time/readers/english.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"english.d.ts","sourceRoot":"","sources":["../../../../../src/core/time/readers/english.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuEG;AAEH,OAAO,EAML,KAAK,UAAU,EAIhB,MAAM,cAAc,CAAC;AAItB,qFAAqF;AACrF,eAAO,MAAM,sBAAsB,2BAA2B,CAAC;AAC/D,qEAAqE;AACrE,eAAO,MAAM,2BAA2B,UAAU,CAAC;AA+iBnD,6CAA6C;AAC7C,MAAM,WAAW,wBAAwB;IACvC;;;;OAIG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,GAAE,wBAA6B,GAAG,UAAU,CAQpF"}

package/dist/types/core/time/readingAsk.d.ts

@@ -0,0 +1,46 @@
+/**
+ * core/time/readingAsk — the choices an OPEN reading offers (time design
+ * § 6.1, § 6.3): the one field a `time-reading` row whose choice is `open`
+ * needs.
+ *
+ * Pattern: a pure builder over the row — the candidates as labelled choices,
+ *          a zone asked as `format: 'zone'`, a `model` reading offered to
+ *          confirm. The judge of the answer stays `ask.ts` ·
+ *          `checkTimeAnswer`.
+ * Role:    core/ leaf (the time layer). Split from `ask.ts` because its
+ *          labels render through `present.ts` (`presentRange`), and `ask.ts`
+ *          is on the resume door's SYNCHRONOUS path (`core/inputRequest.ts`)
+ *          while the renderer loads only under `.time()` — the
+ *          optional-family law of docs-next's site budget.
+ * Emits:   N/A.
+ *
+ * @example
+ * ```ts
+ * const ask = timeAskOf(row, defaultTimeAskMessages);
+ * ask?.field.format; // 'time-range' — its `enum` the candidates left
+ * ```
+ */
+import { type TimeAskMessages, type TimeFormat } from './ask.js';
+import type { TimeReadingRow } from './rows.js';
+/** A time field built from a reading — the fields of `core/inputRequest.ts` · `InputField` it sets. */
+export interface TimeAskField {
+    readonly id: string;
+    readonly type: 'string';
+    readonly required: true;
+    readonly format: TimeFormat;
+    readonly enum?: readonly string[];
+    readonly labels?: readonly string[];
+}
+/** One question about one mention: the question and its field. */
+export interface TimeAsk {
+    readonly question: string;
+    readonly field: TimeAskField;
+}
+/**
+ * The ask a `time-reading` row needs, or `undefined` when its reading is
+ * settled (`only`, `policy`) or cannot be asked about (`none`, a refused
+ * mention). `messages` is the whole catalog (the caller composes the app's
+ * overrides over `defaultTimeAskMessages`); `id` names the field.
+ */
+export declare function timeAskOf(row: TimeReadingRow, messages: TimeAskMessages, id?: string): TimeAsk | undefined;
+//# sourceMappingURL=readingAsk.d.ts.map

package/dist/types/core/time/readingAsk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readingAsk.d.ts","sourceRoot":"","sources":["../../../../src/core/time/readingAsk.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAuB,KAAK,eAAe,EAAE,KAAK,UAAU,EAAE,MAAM,UAAU,CAAC;AAGtF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAKhD,uGAAuG;AACvG,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;IAC5B,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACrC;AAED,kEAAkE;AAClE,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;CAC9B;AAWD;;;;;GAKG;AACH,wBAAgB,SAAS,CACvB,GAAG,EAAE,cAAc,EACnB,QAAQ,EAAE,eAAe,EACzB,EAAE,SAAS,GACV,OAAO,GAAG,SAAS,CA+CrB"}

package/dist/types/core/time/resolve.d.ts

@@ -0,0 +1,104 @@
+/**
+ * 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' } }
+ * ```
+ */
+import { type ZoneName } from './zone.js';
+import type { TimeParts } from './reader.js';
+import { type MentionResolution, type ReadingChoice, type ResolveClock, type TimePolicy } from './resolveRecord.js';
+export { candidateIsWellFormed, choiceIsWellFormed, DEFAULT_TIME_POLICY, readPolicy, } from './resolveRecord.js';
+export type { MentionResolution, OpenQuestion, ReadingChoice, ReadingTags, ResolveClock, ResolvedWindow, TimeCandidate, TimeNote, TimePart, TimePolicy, TimeWindow, } from './resolveRecord.js';
+/**
+ * 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' }]
+ * ```
+ */
+export declare function withZoneAnswered(parses: readonly TimeParts[], zone: ZoneName): TimeParts[];
+/**
+ * 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: []`.
+ */
+export declare function resolveMention(parses: readonly TimeParts[], clock: ResolveClock, reader: {
+    readonly id: string;
+    readonly kind: 'rule' | 'model';
+}, confirm?: boolean): MentionResolution;
+/**
+ * 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.
+ */
+export declare function chooseReading(resolution: MentionResolution, policy: TimePolicy, kind: 'rule' | 'model', problem?: 'unreadable', confirm?: boolean): ReadingChoice;
+//# sourceMappingURL=resolve.d.ts.map

package/dist/types/core/time/resolve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../../../../src/core/time/resolve.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoEG;AAIH,OAAO,EAQL,KAAK,QAAQ,EACd,MAAM,WAAW,CAAC;AAEnB,OAAO,KAAK,EAAE,SAAS,EAAY,MAAM,aAAa,CAAC;AACvD,OAAO,EAEL,KAAK,iBAAiB,EAEtB,KAAK,aAAa,EAElB,KAAK,YAAY,EAIjB,KAAK,UAAU,EAChB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EACL,qBAAqB,EACrB,kBAAkB,EAClB,mBAAmB,EACnB,UAAU,GACX,MAAM,oBAAoB,CAAC;AAC5B,YAAY,EACV,iBAAiB,EACjB,YAAY,EACZ,aAAa,EACb,WAAW,EACX,YAAY,EACZ,cAAc,EACd,aAAa,EACb,QAAQ,EACR,QAAQ,EACR,UAAU,EACV,UAAU,GACX,MAAM,oBAAoB,CAAC;AA6B5B;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,SAAS,EAAE,EAAE,IAAI,EAAE,QAAQ,GAAG,SAAS,EAAE,CAW1F;AAqfD;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,SAAS,SAAS,EAAE,EAC5B,KAAK,EAAE,YAAY,EACnB,MAAM,EAAE;IAAE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,EAChE,OAAO,GAAE,OAAiC,GACzC,iBAAiB,CA4BnB;AAwCD;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,UAAU,EAAE,iBAAiB,EAC7B,MAAM,EAAE,UAAU,EAClB,IAAI,EAAE,MAAM,GAAG,OAAO,EACtB,OAAO,CAAC,EAAE,YAAY,EACtB,OAAO,GAAE,OAA0B,GAClC,aAAa,CAsCf"}

package/dist/types/core/time/resolveRecord.d.ts

@@ -0,0 +1,161 @@
+/**
+ * core/time/resolveRecord — what the resolver writes down: the candidate and
+ * choice shapes, the app's policy (read at `.time()`), and the checks the
+ * checkpoint door runs on a filed reading.
+ *
+ * Pattern: the record half of `resolve.ts`, split from the resolver so the
+ *          SYNCHRONOUS doors — `.time({ policy })` (`clock.ts` ·
+ *          `readTimeOptions`) and `validateCheckpoint` (`rows.ts` ·
+ *          `timeRowIsWellFormed`) — reach the shapes and their checks without
+ *          the resolver, which only an armed seed loads (`agent/stages/
+ *          timeLayer.ts`, through `import()`: the optional-family law of
+ *          docs-next's site budget). `resolve.ts` re-exports everything here.
+ * Role:    core/ leaf (the time layer). Imports `range.ts` and `zone.ts`
+ *          (the window check) only.
+ * Emits:   N/A.
+ *
+ * @example
+ * ```ts
+ * readPolicy({ dateOrder: 'DMY' }); // { dateOrder: 'DMY', year: 'ask' }
+ * candidateIsWellFormed({ kind: 'range', range: { from: 'x', to: 'y' } }); // false
+ * ```
+ */
+import type { InstantText } from './instant.js';
+import type { DurationText } from './duration.js';
+import { type TimeRange } from './range.js';
+import { type ZoneName } from './zone.js';
+import type { Grain } from './present.js';
+/** A part of a time a person can say. `duration`: the length of a look-back ("last 40 minutes"). */
+export type TimePart = 'year' | 'month' | 'day' | 'hour' | 'minute' | 'second' | 'meridiem' | 'zone' | 'duration';
+/** What was asked, before the clock is applied. */
+export type TimeWindow = {
+    readonly kind: 'range';
+    readonly range: TimeRange;
+}
+/** Always "until the clock's now". */
+ | {
+    readonly kind: 'lookback';
+    readonly duration: DurationText;
+};
+/** A library-written note on how a window was read. */
+export type TimeNote = 
+/** The range runs to the end of its last said grain ("to 8:40" → `08:41`). */
+{
+    readonly kind: 'end-of-grain';
+}
+/** A wall time the clocks go back through: which of its two instants this is (`end`: which end of a range). */
+ | {
+    readonly kind: 'dst-overlap';
+    readonly which: 'earlier' | 'later';
+    readonly end?: 'from' | 'to';
+}
+/** A wall time the clocks skip: which of Temporal's two readings this is. */
+ | {
+    readonly kind: 'dst-gap';
+    readonly which: 'earlier' | 'later';
+    readonly end?: 'from' | 'to';
+}
+/** The person said a numeric offset, not a zone: the instants carry it; `zone` is the clock's. */
+ | {
+    readonly kind: 'offset-said';
+    readonly offset: string;
+}
+/** A two-digit year, read in the clock's century. */
+ | {
+    readonly kind: 'century-implied';
+    readonly century: number;
+};
+/** Which reading of the PARTS produced a candidate, so a policy — or an ask — can choose among them. */
+export interface ReadingTags {
+    readonly dateOrder?: 'MDY' | 'DMY' | 'YMD';
+    /** The meridiem this reading gave a clock time said without one (the `from` end of a range). */
+    readonly meridiem?: 'am' | 'pm';
+    /** The same, for the `to` end of a range. */
+    readonly endMeridiem?: 'am' | 'pm';
+    readonly year?: 'said' | 'current' | 'previous';
+}
+/** A window read from words, resolved against the clock (§ 3.2). */
+export interface ResolvedWindow {
+    readonly window: TimeWindow;
+    /** Always present: a look-back resolved against the clock. Spelled in the offset the person meant. */
+    readonly range: TimeRange;
+    /** The zone the person meant, else the clock's. */
+    readonly zone: ZoneName;
+    /** The finest part the person said. */
+    readonly grain: Grain;
+    /** The parts the person said — empty for a `model` reader's reading (§ 5.5). */
+    readonly said: readonly TimePart[];
+    /** The parts this module filled: from the clock, the policy's candidates, the century. */
+    readonly implied: readonly TimePart[];
+    readonly anchor: 'message' | 'previous-window' | 'none';
+    readonly reader: {
+        readonly id: string;
+        readonly kind: 'rule' | 'model';
+    };
+    readonly notes: readonly TimeNote[];
+}
+/** One candidate — produced here, never by a strategy. */
+export interface TimeCandidate extends ResolvedWindow {
+    readonly reading: ReadingTags;
+    /** Which of the mention's parses it came from. */
+    readonly parse: number;
+}
+/** The v1 policy (§ 11): the two switches with two careful answers. */
+export interface TimePolicy {
+    /** `'ask'`: a numeric date's readings become choices. Or the one order this app's people write. */
+    readonly dateOrder: 'ask' | 'MDY' | 'DMY' | 'YMD';
+    /** `'ask'`: a date said without a year is asked. `'current'`: the clock's year, recorded as assumed. */
+    readonly year: 'ask' | 'current';
+}
+/** No silent MDY, no guessed year. */
+export declare const DEFAULT_TIME_POLICY: TimePolicy;
+/** What the clock gives the resolver. */
+export interface ResolveClock {
+    readonly now: InstantText;
+    readonly zone: ZoneName;
+}
+/** Every candidate of one mention, and what kept a parse from any. */
+export interface MentionResolution {
+    readonly candidates: readonly TimeCandidate[];
+    /** A zone the person said that names no zone this layer can read (`PST`): the zone must be asked. */
+    readonly needsZone: boolean;
+    /** Parts v1 does not resolve, named. */
+    readonly unsupported: readonly string[];
+}
+/** A question only the person can settle. */
+export type OpenQuestion = 'date-order' | 'year' | 'meridiem' | 'dst' | 'zone' | 'parse' | 'confirm';
+/** How a mention's reading settled — recorded on its `time-reading` row. */
+export type ReadingChoice = 
+/** Every candidate left names the same window. */
+{
+    readonly by: 'only';
+    readonly candidate: number;
+}
+/** The policy removed a reading and one window is left — assumed, recorded. */
+ | {
+    readonly by: 'policy';
+    readonly candidate: number;
+    readonly policy: Partial<TimePolicy>;
+}
+/** An ask must settle it (a later step raises it): the candidates left and the questions. */
+ | {
+    readonly by: 'open';
+    readonly remaining: readonly number[];
+    readonly open: readonly OpenQuestion[];
+    readonly policy?: Partial<TimePolicy>;
+} | {
+    readonly by: 'none';
+    readonly why: 'unreadable' | 'unsupported' | 'no-candidate' | 'excluded-by-policy';
+};
+/**
+ * The app's `policy`, read with the v1 defaults filled in — or a problem in
+ * words (an unknown key, a value outside its switch).
+ */
+export declare function readPolicy(value: unknown): TimePolicy | string;
+/** The parts a candidate can name, in the order a record lists them. */
+export declare const PART_ORDER: readonly TimePart[];
+/** Whether `value` is a candidate this module would have written. */
+export declare function candidateIsWellFormed(value: unknown): boolean;
+/** Whether `value` is a choice this module would have written over `count` candidates. */
+export declare function choiceIsWellFormed(value: unknown, count: number): boolean;
+//# sourceMappingURL=resolveRecord.d.ts.map

package/dist/types/core/time/resolveRecord.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveRecord.d.ts","sourceRoot":"","sources":["../../../../src/core/time/resolveRecord.ts"],"names":[],"mappings":"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"}