agentfootprint 10.2.0 → 10.3.1

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

@@ -1,170 +0,0 @@
-/**
- * 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';
-    /**
-     * `'24h'`: the text's FORM is a 24-hour clock (an ISO instant's
-     * `T08:00`), so the hour is read as written — never also as pm. A form
-     * fact the reader sees and `resolve.ts` cannot; absent, an hour 1–12 with
-     * no meridiem is read both ways. Never with `meridiem`.
-     */
-    readonly clock?: '24h';
-}
-/** 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

@@ -1 +0,0 @@
-{"version":3,"file":"reader.d.ts","sourceRoot":"","sources":["../../../../src/core/time/reader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAIH,oGAAoG;AACpG,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,UAAU;IACzB,mFAAmF;IACnF,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,6CAA6C;IAC7C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IAChC,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,GAAG,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;CAClF;AAED,4FAA4F;AAC5F,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,QAAQ,EAAE,SAAS,WAAW,EAAE,CAAC;CAC3C;AAED,yCAAyC;AACzC,MAAM,WAAW,WAAW;IAC1B,gEAAgE;IAChE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,0FAA0F;IAC1F,QAAQ,CAAC,MAAM,EAAE,SAAS,SAAS,EAAE,CAAC;IACtC,wDAAwD;IACxD,QAAQ,CAAC,OAAO,CAAC,EAAE,YAAY,CAAC;CACjC;AAED,mCAAmC;AACnC,MAAM,MAAM,QAAQ;AAClB,0GAA0G;AACxG;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC,GAAG,CAAC,CAAA;CAAE;AAC/F,sDAAsD;GACpD;IACE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB,CAAC;AAEN,wDAAwD;AACxD,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,QAAQ,CAAC,EAAE,IAAI,GAAG,IAAI,CAAC;IAChC;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC;CACxB;AAED,oDAAoD;AACpD,MAAM,MAAM,YAAY;AACtB,qDAAqD;AACnD;IACE,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,KAAK,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;IACrE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AACH,2EAA2E;GACzE;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,QAAQ,GAAG,MAAM,GAAG,KAAK,GAAG,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAE7F,uFAAuF;AACvF,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,IAAI,CAAC,EAAE,QAAQ,CAAC;IACzB,QAAQ,CAAC,IAAI,CAAC,EAAE,QAAQ,CAAC;IACzB,uFAAuF;IACvF,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,CAAC,EAAE,YAAY,CAAC;IACjC,qDAAqD;IACrD,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,kFAAkF;IAClF,QAAQ,CAAC,MAAM,CAAC,EAAE,UAAU,CAAC;IAC7B,2BAA2B;IAC3B,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;CACpD;AAID,+FAA+F;AAC/F,eAAO,MAAM,YAAY,KAAK,CAAC;AAC/B,4CAA4C;AAC5C,eAAO,MAAM,UAAU,IAAI,CAAC;AAuB5B,8EAA8E;AAC9E,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAa9D;AAID,yGAAyG;AACzG,MAAM,MAAM,cAAc,GAAG,mBAAmB,GAAG,WAAW,CAAC;AAE/D,oCAAoC;AACpC,MAAM,MAAM,cAAc,GACtB;IACE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,SAAS,SAAS,EAAE,CAAC;IACtC,QAAQ,CAAC,OAAO,CAAC,EAAE,YAAY,CAAC;CACjC,GACD;IAAE,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAA;CAAE,CAAC;AA2EzC,yGAAyG;AACzG,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,UAAQ,GAAG,KAAK,IAAI,SAAS,CAe9E;AA0BD;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,cAAc,EAAE,CAS7F"}

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

@@ -1,147 +0,0 @@
-/**
- * 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 token (an abbreviation, a place) to a zone 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` (marked `clock: '24h'` — never also pm), `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`, `today between 1 pm and 2 pm` | `rangeOf` (a day or zone said once for both sides is the whole mention's) |
- * | a zone after a time, a date or a day word | `America/Los_Angeles`, `UTC-07:00`, `London time`, `PST` | `zoneToken`, as written — `resolve.ts` maps it (a place the tz database names once; an abbreviation only through the app's map; else ASKED) |
- * | a named-month date | `11 September`, `Sept 29`, `September 29, 2026`, `the 29th of Sep` | `date: fixed` — no `year` unless written (the policy's or the person's, as for `10/9`) |
- * | a day word | today, yesterday, tomorrow | `relative: { unit: 'day', offset }` |
- * | a relative span from now | last 40 minutes, past 2 hours, last 24h, past 6h, the last hour, the past week | `relative: { unit, count }` — a look-back in minutes, hours, days or weeks, spelled out or compact (`m`, `h`, `d`, `w`) |
- *
- * ## What it says "unreadable" for — never a partial reading
- *
- * Parts of the day (`yesterday morning`, `tonight`, `noon` — a greeting, `Good morning`, is
- * no time and reads no mention), calendar spans
- * (`last week`, `this month`), week days and a month named alone (`Friday`,
- * `in September`), `N hours ago`, spans in words (`last two hours`), in a unit it
- * does not read (`last 30 seconds`, `last 30s`, `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`), a
- * bare first side whose far side says no meridiem (`8 to 9:30` — `9:30` alone
- * would drop the start) 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.2.0";
-/** A word right before a phrase that changes what it means: the phrase is not read. */
-export declare const MODIFIER_BEFORE: RegExp;
-/** `from` with no `to`: a time after it is where a window STARTS (`from 3 PM yesterday`), not an hour. */
-export declare const FROM_BEFORE: RegExp;
-/**
- * A bare number joined to a clock time as a range's first side the grammar
- * does not read (`8 to 9:30`, `from 8 to 9:30`, `between 8 and 9:30` — the
- * far side says no meridiem, so `8` is no time): the whole phrase is not
- * read. Reading `9:30` alone would drop the start the person said.
- */
-export declare const BARE_SIDE_BEFORE: RegExp;
-/**
- * Whether some span of `covering` holds `span` whole — `covering.some((a) =>
- * a.start <= span.start && span.end <= a.end)` — answered by binary search:
- * among the spans starting at or before `span.start`, the farthest end. Asking
- * `some` once per match cost matches × phrases, and a long message has many of
- * both.
- */
-export declare function coverage(covering: readonly {
-    readonly start: number;
-    readonly end: number;
-}[]): (span: {
-    readonly start: number;
-    readonly end: number;
-}) => boolean;
-/**
- * `/\bbetween\s+$/i.test(text.slice(0, end))` — `between`, then blanks right
- * up to `end` — walked back from `end`. The regex read the whole text before
- * each phrase it was asked about, so a message of many short phrases cost its
- * length times their number.
- */
-export declare function saysBetweenBefore(text: string, end: number): boolean;
-/**
- * Where the text before `end` that those three patterns can reach starts: back
- * over the blanks before `end`, then over `WORDS_BEFORE` words and the blanks
- * before each. Each pattern ends at `end` (`\s*$`), spans fewer words, and
- * takes its leading boundary from the character just before its first word —
- * all inside this window, which starts at a blank or at 0, so the window's
- * `^` adds no match. The leftmost match in the window is therefore the leftmost
- * match in all the text before `end`; matching that text instead re-read the
- * whole message once per group.
- */
-export declare function windowBefore(text: string, end: number): number;
-/** 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

@@ -1 +0,0 @@
-{"version":3,"file":"english.d.ts","sourceRoot":"","sources":["../../../../../src/core/time/readers/english.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2EG;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;AAuFnD,uFAAuF;AACvF,eAAO,MAAM,eAAe,QAK3B,CAAC;AACF,0GAA0G;AAC1G,eAAO,MAAM,WAAW,QAA2B,CAAC;AACpD;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,QAG5B,CAAC;AAiTF;;;;;;GAMG;AACH,wBAAgB,QAAQ,CACtB,QAAQ,EAAE,SAAS;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;CAAE,EAAE,GACpE,CAAC,IAAI,EAAE;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;CAAE,KAAK,OAAO,CAgBrE;AAKD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CASpE;AASD;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAQ9D;AAgQD,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

@@ -1,50 +0,0 @@
-/**
- * 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 is no person's words (a refused mention).
- * Words the library holds NO reading of (`none`: unreadable, no candidate)
- * are asked too — which time the person meant, free entry, nothing
- * pre-filled (`ask.which`, `format: 'time-range'`): the person wrote a time,
- * and a tool's default never stands in for it. `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

@@ -1 +0,0 @@
-{"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;AAMhD,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;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CACvB,GAAG,EAAE,cAAc,EACnB,QAAQ,EAAE,eAAe,EACzB,EAAE,SAAS,GACV,OAAO,GAAG,SAAS,CA6DrB"}

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

@@ -1,130 +0,0 @@
-/**
- * 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 — one when the form is a 24-hour clock (`clock: '24h'`, an ISO instant) |
- * | 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, year and abbreviation reading, `from` before `to`; a first side with no meridiem takes the second's (`8 to 9 PM` → 8 PM) unless that runs backwards (`11 to 1 PM` → 11 AM); two sides with none share one (`8:45 to 8:55` → AM–AM and PM–PM, never 8:45 AM – 8:55 PM) unless neither runs forward (`11 to 1` → 11 AM – 1 PM, and 11 PM – 1 AM the next day); any range that runs forward on no one day ends the next one, within the half-day (`11 PM to 1 AM`, `23:00 to 1:00`) |
- * | a place named with `time` (`London time`) | the ONE zone the tz database has for it (`zone.ts` · `zoneOfPlace`), noted `zone-read`; none or several → the zone is asked |
- * | any mention that names no zone, while the clock's zone is unknown (`zoneSource: 'unknown'`, G15) | none — the person's zone is asked first (`needsZone`) |
- * | an abbreviation in the app's map (`PST`) | its zone's reading AND its literal offset's, when they name different windows — tagged `abbreviation`, noted `zone-read` |
- *
- * The fixed laws: a time is read to the END OF ITS GRAIN ("to 8:40" is
- * `[08:00, 08:41)`, a lone "9 AM" is `[09:00, 10:00)`, a day ends at the next
- * midnight — each noted `end-of-grain`) EXCEPT a range end said as an
- * o'clock hour, which is a boundary on the clock face and ends AT that
- * instant ("8 AM to 9 AM" is `[08:00, 09:00)`, no note — `endOf`); whether
- * an end was widened is asked of `widenedGrain`, never 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, a
- * numeric offset, a place named with `time` that the tz database names
- * exactly once, or an abbreviation in the APP's map (`policy.abbreviations`)
- * — any other token (`PST` with no map, `India time`, `Pacific time`)
- * resolves nothing and is ASKED (`zoneReadsOf`, the one owner). 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, shownGrain, widenedGrain, } from './resolveRecord.js';
-export type { MentionResolution, OpenQuestion, ReadingChoice, ReadingTags, ResolveClock, ResolvedWindow, TimeCandidate, TimeNote, TimePart, TimePolicy, TimeWindow, ZoneAbbreviation, } from './resolveRecord.js';
-/**
- * `London time`, `New York time` — a place named with the word `time` (the
- * reader keeps it as written): `/^(.+?)\s+time$/i.exec(token)?.[1]`, in one
- * pass. That regex grew its lazy place one character at a time and, at each,
- * re-read the blank run after it looking for `time` — quadratic on a letter, a
- * long blank run and anything but `time`, and a token can come straight from
- * the message. The place is everything before the blank run that ends just
- * before `time` (at least one character), and holds no line break, which `.`
- * would not match.
- */
-export declare function placeBeforeTime(token: string): string | undefined;
-/** The policy half the resolver reads: the app's abbreviation map. */
-type ZonePolicy = Pick<TimePolicy, 'abbreviations'>;
-/**
- * The parts with every zone token this layer cannot read (an abbreviation
- * outside the app's map, `India time`) 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, policy?: ZonePolicy): 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: []`.
- * `policy` is read for its abbreviation map only (`dateOrder` and `year`
- * are {@link chooseReading}'s): absent, no abbreviation names a zone.
- */
-export declare function resolveMention(parses: readonly TimeParts[], clock: ResolveClock, reader: {
-    readonly id: string;
-    readonly kind: 'rule' | 'model';
-}, confirm?: boolean, policy?: ZonePolicy): 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

@@ -1 +0,0 @@
-{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../../../../src/core/time/resolve.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8EG;AAIH,OAAO,EAUL,KAAK,QAAQ,EACd,MAAM,WAAW,CAAC;AAEnB,OAAO,KAAK,EAAE,SAAS,EAAY,MAAM,aAAa,CAAC;AACvD,OAAO,EAGL,KAAK,iBAAiB,EAEtB,KAAK,aAAa,EAElB,KAAK,YAAY,EAIjB,KAAK,UAAU,EAEhB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EACL,qBAAqB,EACrB,kBAAkB,EAClB,mBAAmB,EACnB,UAAU,EACV,UAAU,EACV,YAAY,GACb,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,EACV,gBAAgB,GACjB,MAAM,oBAAoB,CAAC;AA0B5B;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAWjE;AAqCD,sEAAsE;AACtE,KAAK,UAAU,GAAG,IAAI,CAAC,UAAU,EAAE,eAAe,CAAC,CAAC;AA6DpD;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,SAAS,SAAS,EAAE,EAC5B,IAAI,EAAE,QAAQ,EACd,MAAM,CAAC,EAAE,UAAU,GAClB,SAAS,EAAE,CAWb;AAgsBD;;;;;;GAMG;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,EAC1C,MAAM,CAAC,EAAE,UAAU,GAClB,iBAAiB,CA4BnB;AAyCD;;;;;;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"}