agentfootprint 9.128.1 → 9.131.0

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

@@ -0,0 +1,85 @@
+/**
+ * core/time/forms — every spelling of a time the answer may write, split by
+ * WHO produced it (time design § 9.5, step T7).
+ *
+ * Pattern: a pure function over recorded values — the person's text, or one
+ *          window the record holds — never over the answer. The evidence gate
+ *          asks it (`evidence/evidenceIndex.ts` · `exemptFromRun`,
+ *          `stages/timeLineage.ts` · `timeLineageOf`) and never keeps a time table of
+ *          its own.
+ * Role:    core/ leaf (the time layer). Imports `windows.ts`, `rows.ts`,
+ *          `resolve.ts`, `textForms.ts` (the text rule, split out so the
+ *          evidence gate's synchronous corpus never loads the resolver),
+ *          `instant.ts` and `zone.ts` only. Loaded under `.time()` only,
+ *          through `import()` (`stages/timeLineage.ts`).
+ * Emits:   N/A.
+ *
+ * ## The two lists
+ *
+ * - **`said`** — spellings of the parts the PERSON said, at the grain they
+ *   said them: "8 AM" said at grain hour is also `8:00` and `08:00` — the
+ *   same instant at that grain, equality and not a new fact. They count as
+ *   the person's words (the gate exempts them).
+ * - **`derived`** — everything the LIBRARY produced from a reading: an
+ *   implied year, the zone's abbreviation in effect (`PDT` for a said `PST`),
+ *   offsets, UTC and epoch spellings, the end-of-grain `08:41`, a look-back's
+ *   duration, and every part of a `model` reading. The gate files an answer
+ *   value found only here with the lineage `derived-from-reading`: it can
+ *   support "not sure", never "known", and it is never called invented.
+ *
+ * A time value no recorded reading produced is in neither list and still
+ * fails the gate. Library text is never evidence: without `derived`, a model
+ * echoing the served time line back would read as the person's words.
+ */
+import { type TimeForms } from './textForms.js';
+import { type TurnWindow } from './windows.js';
+import { type TimeCandidate } from './resolve.js';
+export type { TimeForms };
+/** One window the record holds, as the spellings read it. */
+export interface FormsWindow extends Pick<TurnWindow, 'source' | 'range' | 'zone' | 'lookback'> {
+    /**
+     * The reading this window IS, when the person confirmed a `rule` reading
+     * of their words — which parts they WROTE, and how the range was read.
+     * Absent: a window they typed in the ask, a UI control, a `model` reading.
+     */
+    readonly reading?: Pick<TimeCandidate, 'said' | 'notes' | 'grain'>;
+    /** On an `answered` window: the person picked the offered reading, or wrote their own. */
+    readonly answer?: TurnWindow['answer'];
+}
+/** What {@link timeFormsOf} spells: words the person or the app wrote, or one recorded window. */
+export type TimeFormsSource = {
+    readonly text: string;
+} | {
+    readonly window: FormsWindow;
+};
+/**
+ * The spellings of one source's times, split by lineage (§ 9.5).
+ *
+ * A `text` — the person's message, their typed answer, the app's prompt —
+ * has only `said` spellings, and each is a SPELLING, never an
+ * interpretation: an ISO date → its year, month and day; a 12-hour reading
+ * (`8 Am`) → its 24-hour, padded and glued forms; a 24-hour reading
+ * (`20:00`) → the same set. Slash dates are never read (their order is a
+ * locale) and durations never (a quantity is not a time of day).
+ *
+ * A `window` — the turn's recorded window — splits by who produced each
+ * part: the person's said parts at grain, or everything of a window they
+ * typed or set in a UI, are `said`; the rest is `derived`. A `model`
+ * reading's window (`derived-from-reading`) has no `said` spelling at all.
+ *
+ * @example
+ * ```ts
+ * timeFormsOf({ text: 'what connected 8 Am to 8:40 AM PST' }).said;
+ * // ['8:00', '08:00', '8:00am', '8:40', '08:40', '8:40am']
+ * timeFormsOf({ text: '2026-10-09' }).said; // ['2026', '10', '9']
+ * timeFormsOf({ text: 'took 2h' });         // { said: [], derived: [] }
+ * ```
+ */
+export declare function timeFormsOf(source: TimeFormsSource): TimeForms;
+/**
+ * Every recorded window of the LATEST turn on the ledger (its `clock` row's
+ * turn), with the reading each one is — what the gate spells. Empty when no
+ * clock was filed (an agent without `.time()`).
+ */
+export declare function turnFormsWindowsOf(ledger: readonly unknown[] | undefined): readonly FormsWindow[];
+//# sourceMappingURL=forms.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"forms.d.ts","sourceRoot":"","sources":["../../../../src/core/time/forms.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,OAAO,EAAoD,KAAK,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAClG,OAAO,EAAiB,KAAK,UAAU,EAAE,MAAM,cAAc,CAAC;AAE9D,OAAO,EAIL,KAAK,aAAa,EAEnB,MAAM,cAAc,CAAC;AAItB,YAAY,EAAE,SAAS,EAAE,CAAC;AAE1B,6DAA6D;AAC7D,MAAM,WAAW,WAAY,SAAQ,IAAI,CAAC,UAAU,EAAE,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,UAAU,CAAC;IAC7F;;;;OAIG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,IAAI,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC,CAAC;IACnE,0FAA0F;IAC1F,QAAQ,CAAC,MAAM,CAAC,EAAE,UAAU,CAAC,QAAQ,CAAC,CAAC;CACxC;AAED,kGAAkG;AAClG,MAAM,MAAM,eAAe,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAA;CAAE,CAAC;AAK3F;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,eAAe,GAAG,SAAS,CAG9D;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,OAAO,EAAE,GAAG,SAAS,GAAG,SAAS,WAAW,EAAE,CAMjG"}

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

@@ -0,0 +1,76 @@
+/**
+ * core/time/instant — the ONE instant parser, with two named profiles.
+ *
+ * Pattern: one grammar, named profiles (never a second parser). Moved from
+ *          `coverage/period.ts` (where it read a result's declared period)
+ *          and `arguments/declare.ts` (where a regex plus `Date.parse` checked
+ *          an `iso-range` argument). Exact: no `Date.parse` guessing, no
+ *          sub-millisecond loss.
+ * Role:    core/ leaf (the time layer's one owner, `src/core/time/`). Imports
+ *          nothing. Asked by `coverage/period.ts` (lenient) and, through
+ *          `range.ts` · `splitRange`, by `arguments/declare.ts` (strict).
+ * Emits:   N/A.
+ *
+ * ## The two profiles
+ *
+ * | Profile   | For | `t`/`z` lower case | second `60` | day past the month's end, hour 24 |
+ * |-----------|-----|--------------------|-------------|-----------------------------------|
+ * | `lenient` | a period a result DECLARES — RFC 3339 as a foreign minter may write it | accepted | accepted (compares as the next minute's `:00`) | refused |
+ * | `strict`  | a value the library SENDS to a tool — the canonical spelling a backend such as Python's `datetime.fromisoformat` takes | refused | refused | refused |
+ *
+ * Both require a zone (`Z` or `±HH:MM`): an instant with no zone could be any
+ * of 24 hours, so it is refused rather than guessed.
+ *
+ * @example
+ * ```ts
+ * instantOf('2026-10-09T08:00:00-07:00', 'strict');  // { ms: 1791558000000, nanos: 0, offsetMinutes: -420, precision: 'second' }
+ * instantOf('2026-10-09t08:00z', 'strict');           // undefined — lower case is lenient-only
+ * instantOf('2026-02-30T08:00Z', 'lenient');          // undefined — 30 February does not exist
+ * toUtc('2026-10-09T08:00-07:00', 'strict');          // '2026-10-09T15:00:00Z'
+ * ```
+ */
+/** An ISO 8601 instant WITH an offset (`Z` or `±HH:MM`). */
+export type InstantText = string;
+/** Which spelling of an instant is accepted — see the module table. */
+export type InstantProfile = 'lenient' | 'strict';
+/**
+ * One instant, comparable exactly: whole milliseconds since the epoch, and the
+ * nanoseconds below that millisecond (0–999 999), so a 9-digit fraction is
+ * never rounded.
+ */
+export interface Instant {
+    readonly ms: number;
+    readonly nanos: number;
+}
+/** A parsed instant: the instant, the offset it was written in, and how finely it was written. */
+export interface ParsedInstant extends Instant {
+    /** The written offset in minutes east of UTC (`Z` is 0). */
+    readonly offsetMinutes: number;
+    /** The finest part written: minutes only, seconds, or a fraction of a second. */
+    readonly precision: 'minute' | 'second' | 'fraction';
+}
+/** Days in `month` (1–12) of the proleptic Gregorian `year`. */
+export declare const daysInMonth: (year: number, month: number) => number;
+/** Milliseconds since the epoch of a UTC wall time. `setUTCFullYear`, never `Date.UTC`: the latter reads years 0–99 as 1900–1999. */
+export declare function utcWallMs(year: number, month: number, day: number, hour: number, minute: number, second: number, millisecond?: number): number;
+/**
+ * The instant a string names under `profile`, or `undefined` when it is not
+ * an ISO 8601 instant with a zone in that profile (a date alone, a time with
+ * no zone, a day that does not exist, hour 24, prose). The profile is always
+ * named by the caller: there is no default spelling of "an instant".
+ */
+export declare function instantOf(value: unknown, profile: InstantProfile): ParsedInstant | undefined;
+/** -1 / 0 / 1 — `a` before, at, or after `b`. */
+export declare function compareInstants(a: Instant, b: Instant): number;
+/** `instant` moved by a whole number of milliseconds (negative moves it earlier). */
+export declare function shiftInstant(instant: Instant, byMs: number): Instant;
+/**
+ * The strict-profile spelling of `instant` in the offset `offsetMinutes`
+ * (`Z` when 0): seconds always written, a fraction only when it is not zero,
+ * with no trailing zeros. `undefined` when the offset is not a whole number of
+ * minutes within ±23:59, or the year in that offset falls outside 0000–9999.
+ */
+export declare function spellInstant(instant: Instant, offsetMinutes: number): InstantText | undefined;
+/** The same instant spelled in UTC (`Z`), strict profile — or `undefined` when `value` is not an instant under `profile`. */
+export declare function toUtc(value: unknown, profile: InstantProfile): InstantText | undefined;
+//# sourceMappingURL=instant.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"instant.d.ts","sourceRoot":"","sources":["../../../../src/core/time/instant.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,4DAA4D;AAC5D,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC;AAEjC,uEAAuE;AACvE,MAAM,MAAM,cAAc,GAAG,SAAS,GAAG,QAAQ,CAAC;AAElD;;;;GAIG;AACH,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,kGAAkG;AAClG,MAAM,WAAW,aAAc,SAAQ,OAAO;IAC5C,4DAA4D;IAC5D,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,iFAAiF;IACjF,QAAQ,CAAC,SAAS,EAAE,QAAQ,GAAG,QAAQ,GAAG,UAAU,CAAC;CACtD;AAOD,gEAAgE;AAChE,eAAO,MAAM,WAAW,SAAU,MAAM,SAAS,MAAM,KAAG,MAOlD,CAAC;AAET,qIAAqI;AACrI,wBAAgB,SAAS,CACvB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,WAAW,SAAI,GACd,MAAM,CAKR;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,cAAc,GAAG,aAAa,GAAG,SAAS,CAgC5F;AAED,iDAAiD;AACjD,wBAAgB,eAAe,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,MAAM,CAI9D;AAED,qFAAqF;AACrF,wBAAgB,YAAY,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAKpE;AAID;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CAoB7F;AAED,6HAA6H;AAC7H,wBAAgB,KAAK,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,cAAc,GAAG,WAAW,GAAG,SAAS,CAGtF"}

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

@@ -0,0 +1,185 @@
+/**
+ * core/time/periodForm — a tool's period FORMS as DECLARED (time design § 7.1):
+ * the shapes, the sugar, each form's own rules, a declared value's spelling,
+ * and the tool's facts against a range.
+ *
+ * Pattern: the declaration half of `convert.ts`, split from the conversions so
+ *          the SYNCHRONOUS doors — `defineTool({ period })`
+ *          (`agent/arguments/declare.ts`), a time answer's check at the resume
+ *          door (`ask.ts` · `checkTimeAnswer`) and the checkpoint door's
+ *          refusal codes (`rows.ts`) — reach it without the conversion
+ *          engine, which only an armed agent loads (`bind.ts`, `drift.ts`,
+ *          reached through `import()`: the optional-family law of docs-next's
+ *          site budget). `convert.ts` re-exports everything public here.
+ * Role:    core/ leaf (the time layer). Imports `instant.ts`, `duration.ts`
+ *          and `zone.ts` only.
+ * Emits:   N/A.
+ *
+ * @example
+ * ```ts
+ * const [form] = sugarForms({ argument: 'window', spelling: 'iso-range' });
+ * formIssue(form); // undefined — a well-formed form
+ * parsesUnderForm('2026-10-09T08:00:00-07:00..2026-10-09T08:40:59-07:00', form, 'window'); // true
+ * ```
+ */
+import { type DurationText } from './duration.js';
+import { type InstantText } from './instant.js';
+import type { Edge, TimeRange } from './range.js';
+import { type WallTime } from './zone.js';
+/** The single-argument spellings — today's three, and `wall-range` (wall times plus a zone argument). */
+export type PeriodSpelling = 'lookback' | 'signed-lookback' | 'iso-range' | 'wall-range';
+/** The spellings, in the order the docs list them. */
+export declare const PERIOD_SPELLINGS: readonly PeriodSpelling[];
+/** How one bound is written: an instant with its offset, epoch milliseconds or seconds, a calendar date, a wall time. */
+export type BoundAs = 'iso' | 'epoch-ms' | 'epoch-s' | 'date' | 'wall';
+export declare const BOUND_AS: readonly BoundAs[];
+/**
+ * One bound of a two-argument period. A `from` bound is inclusive (its `edge`,
+ * when written, can only say so); a `to` bound MUST say its edge
+ * ({@link ToBound}) — TQ18: the library never guesses a tool's edge, only the
+ * sugar defaults (`inclusive`).
+ */
+export interface Bound {
+    readonly argument: string;
+    readonly as: BoundAs;
+    readonly edge?: Edge;
+}
+/** The end bound of a `bounds` form — its edge is declared, never defaulted (TQ18). */
+export interface ToBound extends Bound {
+    readonly edge: Edge;
+}
+/** The argument a wall or date form reads its zone from. */
+export interface ZoneArgument {
+    readonly argument: string;
+}
+/** Every shape a tool's period can take — one `TimeRange` onto one or more arguments. */
+export type PeriodForm = {
+    readonly kind: 'bounds';
+    readonly from: Bound;
+    readonly to: ToBound;
+    readonly zone?: ZoneArgument;
+} | {
+    readonly kind: 'joined';
+    readonly argument: string;
+    readonly as: BoundAs;
+    readonly joiner: '..' | '/';
+    readonly edge?: Edge;
+    readonly zone?: ZoneArgument;
+} | {
+    readonly kind: 'object';
+    readonly argument: string;
+    readonly keys: {
+        readonly from: string;
+        readonly to: string;
+    };
+    readonly as: BoundAs;
+    /** Declared, never defaulted (TQ18). */
+    readonly edge: Edge;
+    readonly zone?: ZoneArgument;
+} | {
+    readonly kind: 'day';
+    readonly argument: string;
+    readonly zone?: ZoneArgument;
+} | {
+    readonly kind: 'lookback';
+    readonly argument: string;
+    readonly signed: boolean;
+    /** A unit set ⊆ `smhdw`; absent → today's `mhdw`. */
+    readonly units?: string;
+};
+export declare const FORM_KINDS: readonly PeriodForm['kind'][];
+/** Which side of now a source can hold. */
+export type PeriodDirection = 'past' | 'future' | 'any';
+/** Facts about the source — never policy (§ 7.1). Durations are in `smhdw`. */
+export interface PeriodFacts {
+    readonly direction?: PeriodDirection;
+    readonly retention?: DurationText;
+    readonly maxRange?: DurationText;
+    readonly granularity?: DurationText;
+    readonly filtersToAsked?: boolean;
+}
+/** The unit set of a fact's duration (`retention`, `maxRange`, `granularity`). */
+export declare const FACT_UNITS = "smhdw";
+/** The step a look-back ending "at now" may miss by when no `granularity` is declared (§ 7.4). */
+export declare const DEFAULT_GRANULARITY_MS = 60000;
+/** The form one single-argument spelling means (the module table). */
+export declare function sugarForm(argument: string, spelling: PeriodSpelling, zoneArgument?: string): PeriodForm;
+/** The sugar and general halves of a period declaration, as `sugarForms` reads them. */
+export interface PeriodShapes {
+    readonly argument?: string;
+    readonly spelling?: PeriodSpelling;
+    readonly accepts?: readonly PeriodSpelling[];
+    readonly zoneArgument?: string;
+    readonly forms?: readonly PeriodForm[];
+}
+/**
+ * Every form a declaration names, in preference order: `forms` as written,
+ * else the sugar (`accepts`, else `spelling`). A declaration that names an
+ * argument and no spelling has no form — today's "which argument", nothing
+ * the library can convert into.
+ */
+export declare function sugarForms(period: PeriodShapes): readonly PeriodForm[];
+type Plain = Record<string, unknown>;
+export declare const isPlain: (value: unknown) => value is Plain;
+/**
+ * Why one form's own shape is not a form, or `undefined` when it is one. The
+ * schema half (does the argument exist, is it the right type, does it carry a
+ * rule) is `arguments/declare.ts`'s — this is the shape alone.
+ */
+export declare function formIssue(form: unknown): string | undefined;
+/** Whether a form reads wall-clock values and so needs a zone (`wall`, `date`, a `day`). */
+export declare function needsZone(form: PeriodForm): boolean;
+/** One argument a form names, and what the schema must say of it. */
+export interface FormArgument {
+    readonly argument: string;
+    /** `bound`: carries a value of the window; `zone`: carries the zone; `object`: an object of both bounds. */
+    readonly role: 'bound' | 'zone' | 'object';
+    /** The JSON Schema type the property must have: a number for an epoch, else a string. */
+    readonly type: 'number' | 'string' | 'object';
+    /** For a `bound` of a `bounds` form — the bound it carries. */
+    readonly bound?: Bound;
+}
+/** Every argument a form names, the zone argument last. */
+export declare function formArguments(form: PeriodForm): readonly FormArgument[];
+/** The argument a form is known by — the results layer's join key (its first bound). */
+export declare function primaryArgument(form: PeriodForm): string;
+/** A wall time written with no offset, and the step its spelling is precise to. */
+export declare function wallOf(text: unknown): {
+    readonly wall: WallTime;
+    readonly stepMs: number;
+} | undefined;
+/** A calendar date `YYYY-MM-DD`, day-checked. */
+export declare function dateOf(text: unknown): {
+    readonly year: number;
+    readonly month: number;
+    readonly day: number;
+} | undefined;
+/** Whether a single bound value is written the way `as` declares. */
+export declare function isBoundValue(value: unknown, as: BoundAs): boolean;
+export declare const epochFromText: (text: string) => number | undefined;
+/**
+ * Whether a declared value (an `assume` default, an `ask` choice) of
+ * `argument` is written the way `form` spells that argument. A format check:
+ * no clock, no conversion. `true` for an argument the form does not name.
+ */
+export declare function parsesUnderForm(value: unknown, form: PeriodForm, argument: string): boolean;
+/** Why a range breaks one of the tool's facts — a code; the sentence is the catalog's. */
+export type PeriodFactProblem = 'time-future' | 'time-past' | 'beyond-retention' | 'over-max-range';
+/**
+ * Which of the tool's declared facts a half-open range breaks, against the
+ * turn's clock — or `undefined`. `past`: a range that starts after now;
+ * `future`: one that ends before now; `retention`: only a range WHOLLY older
+ * than `now − retention` (a partial overlap is the result's to judge);
+ * `maxRange`: a range longer than it. A fact the tool does not declare is not
+ * checked.
+ */
+export declare function periodFactProblem(range: TimeRange, facts: PeriodFacts, now: InstantText): PeriodFactProblem | undefined;
+/**
+ * Why a call is refused before dispatch (§ 7.2, step T5b): one of the tool's
+ * facts ({@link PeriodFactProblem}), a range across days to a tool that reads
+ * one day (`multi-day`), or a wall time the zone skips (`dst-gap`).
+ */
+export type TimeRefusal = PeriodFactProblem | 'multi-day' | 'dst-gap';
+export declare const TIME_REFUSALS: readonly TimeRefusal[];
+export {};
+//# sourceMappingURL=periodForm.d.ts.map

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

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

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

@@ -0,0 +1,108 @@
+/**
+ * core/time/present — time rendered for a PERSON, in a named zone.
+ *
+ * Pattern: one renderer, every person-facing line (time design § 3.1, § 10.2):
+ *          the limits block's `Period:` line (`coverage/period.ts` ·
+ *          `periodLine`) and, later, every time label the layer shows. A
+ *          label is never parsed back; the typed record keeps the instants.
+ * Role:    core/ leaf (the time layer). Imports `instant.ts`, `zone.ts` and
+ *          `range.ts` only.
+ * Emits:   N/A.
+ *
+ * ## The form — locale-neutral, the zone always named
+ *
+ * With no locale (no reader armed) there is no language to speak: the
+ * form is ISO-like and the same in every language — a date, a 24-hour wall
+ * time in the presentation zone, then the zone's name and its offset at that
+ * moment:
+ *
+ * ```
+ * 2026-10-09 08:00–08:40 America/Los_Angeles (UTC-07:00)
+ * 2026-10-09 23:00 – 2026-10-10 01:00 Asia/Kolkata (UTC+05:30)
+ * 2026-11-01 01:00 (UTC-07:00) – 2026-11-01 01:30 (UTC-08:00) America/Los_Angeles
+ * 2026-10-09 15:00–15:40 UTC
+ * ```
+ *
+ * The time is written as finely as either end needs it (minutes, seconds, or
+ * milliseconds), never finer. When the two ends sit on different offsets (the
+ * span crosses a DST change) each end names its own; otherwise the offset is
+ * named once.
+ *
+ * ## With a locale (the reader's, § 11)
+ *
+ * A {@link Presentation} with a `locale` — the armed reader's, the language
+ * the person wrote in — is rendered through `Intl.DateTimeFormat` in that
+ * locale, at the same precision, the zone named by its short name
+ * (`Fri, Oct 9, 2026, 8:00 – 8:40 AM PDT` in `en-US`). The words are the
+ * runtime's ICU data; the instants behind the label are the record.
+ *
+ * ## The said end (§ 3.3)
+ *
+ * Inside the library a person's range is half-open: "to 8:40" read to the end
+ * of its grain is `[08:00, 08:41)`. {@link presentRange} with that grain shows
+ * the end AS SAID — the last instant inside the range at the grain,
+ * `08:40` — never `08:41`. A declared period's `queried` / `held` is
+ * inclusive already, so {@link presentSpan} shows its ends as declared.
+ *
+ * @example
+ * ```ts
+ * const la = { zone: 'America/Los_Angeles' };
+ * presentRange({ from: '2026-10-09T08:00:00-07:00', to: '2026-10-09T08:41:00-07:00' }, la, 'minute');
+ * // '2026-10-09 08:00–08:40 America/Los_Angeles (UTC-07:00)'
+ * presentSpan('2026-10-09T15:00:00Z', '2026-10-09T15:40:00Z', la);
+ * // '2026-10-09 08:00–08:40 America/Los_Angeles (UTC-07:00)'
+ * presentInstant('2026-10-09T15:40:03Z', la);
+ * // '2026-10-09 08:40:03 America/Los_Angeles (UTC-07:00)'
+ * ```
+ */
+import { type InstantText } from './instant.js';
+import type { TimeRange } from './range.js';
+import { type ZoneName } from './zone.js';
+/**
+ * Where a label is rendered — the presentation zone, and the locale when a
+ * reader is armed (its `locale`: the language the person wrote in). Without a
+ * locale the form is the locale-neutral one above.
+ */
+export interface Presentation {
+    readonly zone: ZoneName;
+    /** A BCP 47 language tag (`'en-US'`). Rendered through `Intl`; the zone is always named. */
+    readonly locale?: string;
+}
+/** How finely a person said a time (time design § 3.2). */
+export type Grain = 'second' | 'minute' | 'hour' | 'day' | 'week' | 'month' | 'year';
+/**
+ * One instant for a person: its wall time in the presentation zone, written
+ * as finely as it needs (never coarser than minutes), and the zone named.
+ */
+export declare function presentInstant(value: InstantText, presentation: Presentation): string;
+/**
+ * Two INCLUSIVE ends — a declared period's `queried` or `held` — for a
+ * person, each shown as declared (no end moved), in the presentation zone.
+ * Accepts the lenient profile: a period a result declares.
+ */
+export declare function presentSpan(from: InstantText, to: InstantText, presentation: Presentation): string;
+/**
+ * A presentation bound into the three renderers the coverage limits lines use
+ * (`agent/coverage/period.ts` · `periodLine` for a `Period:` line, and
+ * `periodCheckLine` for a result check's ranges). The coverage module is on every
+ * agent's graph and this one loads only under `.time()`, so it is HANDED the
+ * renderers (`agent/stages/prepareFinal.ts` loads this module through
+ * `import()`) and never imports them — the optional-family law of docs-next's
+ * site budget.
+ */
+export interface BoundPresentation {
+    readonly span: (from: InstantText, to: InstantText) => string;
+    readonly instant: (value: InstantText) => string;
+    readonly range: (range: TimeRange, grain?: Grain) => string;
+}
+/** {@link presentSpan}, {@link presentInstant} and {@link presentRange}, bound to one presentation. */
+export declare function bindPresentation(presentation: Presentation): BoundPresentation;
+/**
+ * A half-open range for a person. With the `grain` the person said, the end
+ * is the end AS SAID (§ 3.3): the last instant inside the range, written at
+ * that grain — `[08:00, 08:41)` at `'minute'` shows `08:00–08:40`, and a
+ * `'day'` range `[9 Oct, 10 Oct)` shows `2026-10-09`. Without a grain (an
+ * exact range) both ends are shown as they are.
+ */
+export declare function presentRange(range: TimeRange, presentation: Presentation, grain?: Grain): string;
+//# sourceMappingURL=present.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"present.d.ts","sourceRoot":"","sources":["../../../../src/core/time/present.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AAEH,OAAO,EAAa,KAAK,WAAW,EAAsB,MAAM,cAAc,CAAC;AAC/E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,EAA+C,KAAK,QAAQ,EAAE,MAAM,WAAW,CAAC;AAEvF;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,4FAA4F;IAC5F,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,2DAA2D;AAC3D,MAAM,MAAM,KAAK,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,GAAG,KAAK,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;AAmNrF;;;GAGG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,YAAY,GAAG,MAAM,CASrF;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,WAAW,EACjB,EAAE,EAAE,WAAW,EACf,YAAY,EAAE,YAAY,GACzB,MAAM,CAWR;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,WAAW,EAAE,EAAE,EAAE,WAAW,KAAK,MAAM,CAAC;IAC9D,QAAQ,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,MAAM,CAAC;IACjD,QAAQ,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,CAAC,EAAE,KAAK,KAAK,MAAM,CAAC;CAC7D;AAED,uGAAuG;AACvG,wBAAgB,gBAAgB,CAAC,YAAY,EAAE,YAAY,GAAG,iBAAiB,CAM9E;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,YAAY,EAAE,KAAK,CAAC,EAAE,KAAK,GAAG,MAAM,CA4BhG"}

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

@@ -0,0 +1,128 @@
+/**
+ * core/time/range — the library's one range, its two spellings, and one
+ * conversion per boundary a range crosses.
+ *
+ * Pattern: one internal shape, converted at every edge by a named function —
+ *          never inline. Inside the library a range is HALF-OPEN `[from, to)`;
+ *          the places a range crosses do not share that edge (the time design,
+ *          `docs/design/time/README.md` § 3.3), so each crossing is a function
+ *          here and its inverse.
+ * Role:    core/ leaf (the time layer's one owner). Imports `instant.ts` and
+ *          `duration.ts`. Asked by `arguments/declare.ts` ·
+ *          `parsesUnderSpelling` (an `iso-range` argument is
+ *          {@link splitRange} under `'..'` and the strict profile). No other
+ *          file splits or joins a range.
+ * Emits:   N/A.
+ *
+ * ## The boundaries
+ *
+ * | Boundary | Its edge | Into it from `[from, to)` | Back |
+ * |----------|----------|---------------------------|------|
+ * | a result's `DeclaredPeriod.queried` / `held` | inclusive at both ends | not converted — the tool declares it | {@link fromInclusive} with the tool's step (`granularity`, else 1 ms) |
+ * | a tool argument bound | declared on every `bounds`/`object` end (TQ18); only the sugar defaults inclusive | {@link boundInto} | {@link boundFrom} |
+ * | a look-back argument | `[until − L, until]` | {@link lookbackRange} | {@link lookbackOf} |
+ * | an ask answer / an ISO 8601 interval | `from/to`, half-open | identity: {@link spellRange} | identity: {@link parseRange} |
+ * | an inclusive interval clause (SQL `BETWEEN`, a chart brush) | inclusive at both ends | {@link toInclusive} | {@link fromInclusive} |
+ *
+ * `coverage/period.ts` · `periodVerdict` stays inclusive and is NOT routed
+ * through here: it compares the two inclusive spans a result declared.
+ *
+ * A derived bound keeps the offset its source was written in, spelled in the
+ * strict profile; a bound that is not derived is kept as written.
+ *
+ * @example
+ * ```ts
+ * parseRange('2026-10-09T08:00:00-07:00/2026-10-09T08:41:00-07:00');
+ * // { from: '2026-10-09T08:00:00-07:00', to: '2026-10-09T08:41:00-07:00' }
+ * toInclusive({ from: '2026-10-09T08:00:00-07:00', to: '2026-10-09T08:41:00-07:00' }, 60_000);
+ * // { from: '2026-10-09T08:00:00-07:00', to: '2026-10-09T08:40:00-07:00' } — "through 08:40"
+ * ```
+ */
+import { type DurationText } from './duration.js';
+import { type InstantProfile, type InstantText, type ParsedInstant } from './instant.js';
+/**
+ * The library's INTERNAL range: half-open `[from, to)`, `from` before `to`.
+ * NOT the same reading as `DeclaredPeriod.queried`, whose bounds are
+ * inclusive — every boundary converts (the module table).
+ */
+export interface TimeRange {
+    readonly from: InstantText;
+    readonly to: InstantText;
+}
+/** Two instants with inclusive ends, `from` not after `to` — a declared period's span, an SQL `BETWEEN`. */
+export interface InclusiveSpan {
+    readonly from: InstantText;
+    readonly to: InstantText;
+}
+/** How two bounds are joined in one string: an ISO 8601 interval (`/`) or a tool's joined argument (`..`). */
+export type RangeJoiner = '/' | '..';
+/** Whether a tool's bound includes the instant it names. */
+export type Edge = 'inclusive' | 'exclusive';
+/**
+ * The two bounds of a joined range string — exactly one `joiner`, each half an
+ * instant under `profile` — or `undefined`. The ORDER is not checked: a format
+ * check, for a declaration that only promises a spelling.
+ */
+export declare function splitRange(value: unknown, joiner: RangeJoiner, profile: InstantProfile): readonly [ParsedInstant, ParsedInstant] | undefined;
+/**
+ * A joined string read as a {@link TimeRange} — strict instants, `from`
+ * before `to` — or `undefined`. The bounds are kept as written.
+ */
+export declare function parseRange(value: unknown, joiner?: RangeJoiner): TimeRange | undefined;
+/** Whether `value` is a well-formed {@link TimeRange}: strict instants, `from` before `to`, no other key. */
+export declare function isTimeRange(value: unknown): value is TimeRange;
+/** The range spelled as one string: `from<joiner>to`, bounds as written. Throws on a range that is not well formed. */
+export declare function spellRange(range: TimeRange, joiner?: RangeJoiner): string;
+/** The step a tool's `granularity` names (under `units`), else 1 ms — the § 3.3 rule. */
+export declare function stepMsOf(granularity: DurationText | undefined, units: string): number;
+/**
+ * An inclusive span read back as half-open: `[from, to + step)`. The step is
+ * the source's smallest step (a tool's `granularity`, else 1 ms). The span is
+ * read in the LENIENT profile — a result declares it.
+ */
+export declare function fromInclusive(span: InclusiveSpan, stepMs?: number): TimeRange;
+/**
+ * A half-open range written with inclusive ends: `[from, to − step]` — the
+ * last instant inside the range at the reader's precision. Refused when the
+ * range is narrower than one step (it holds no instant at that precision).
+ */
+export declare function toInclusive(range: TimeRange, stepMs?: number): InclusiveSpan;
+/**
+ * A half-open range's end as a tool's `to` bound: `exclusive` → as is;
+ * `inclusive` → the last instant inside at the argument's precision
+ * (`to − step`).
+ */
+export declare function boundInto(to: InstantText, edge: Edge, stepMs: number): InstantText;
+/** The inverse of {@link boundInto}: a tool's `to` bound as a half-open range's end. */
+export declare function boundFrom(to: InstantText, edge: Edge, stepMs: number): InstantText;
+/**
+ * A look-back `duration` evaluated at `until` — `[until − L, until]`, both
+ * ends inside — as a half-open range `[until − L, until + 1 ms)`.
+ */
+export declare function lookbackRange(until: InstantText, duration: DurationText, units: string): TimeRange;
+/**
+ * The inverse of {@link lookbackRange}: the `until` and the smallest exact
+ * look-back spelling a half-open range is, or `undefined` when its length is
+ * no whole duration in `units`.
+ */
+export declare function lookbackOf(range: TimeRange, units: string): {
+    readonly until: InstantText;
+    readonly duration: DurationText;
+} | undefined;
+/** Whether `outer` holds every instant of `inner` (half-open). */
+export declare function covers(outer: TimeRange, inner: TimeRange): boolean;
+/** Whether two ranges hold the same instants (their spellings and offsets aside). */
+export declare function sameRange(a: TimeRange, b: TimeRange): boolean;
+/** Whether `a` and `b` share at least one instant (half-open: touching ends do not overlap). */
+export declare function overlaps(a: TimeRange, b: TimeRange): boolean;
+/**
+ * The range widened to whole steps — `from` down, `to` up, never inward —
+ * with `rounded` saying whether anything moved. Steps are counted from the
+ * epoch in UTC: right for seconds, minutes and hours; a calendar day or week
+ * in a zone is `zone.ts`'s question, not this one.
+ */
+export declare function roundOutward(range: TimeRange, stepMs: number): {
+    readonly range: TimeRange;
+    readonly rounded: boolean;
+};
+//# sourceMappingURL=range.d.ts.map

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

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