agentfootprint 10.2.0 → 10.3.1

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

@@ -1,148 +0,0 @@
-/**
- * core/time/bind — which of the person's windows a tool call carries (time
- * design § 5.6, § 7.3): fill from one mention, bind by quote, and record a
- * differing model window and run it.
- *
- * Pattern: Walker over recorded rows. The turn's WINDOWS are read from what
- *          the record already holds — this turn's `time-answer` rows (a
- *          mention the person settled in the time ask), a `model` reader's
- *          `time-reading` rows (a reading, never the person's) and the
- *          `clock` row's `control` window — never from words. A `rule`
- *          reading settles nothing: it is a proposal the person confirms
- *          (the owner's decision "Always confirm", time design TQ29). One call's decision
- *          ({@link callWindowOf}) is a pure function of its arguments, the
- *          tool's forms and those windows.
- * Role:    core/ leaf (the time layer). Imports `convert.ts`, `range.ts`,
- *          `rows.ts`, `resolve.ts`' types and `zone.ts` only. Asked by the
- *          inputs layer (`arguments/resolve.ts`), which files the argument
- *          rows and the `call-window` row the decision implies.
- * Emits:   N/A.
- *
- * ## The laws
- *
- * - **Fill only when the turn has exactly one window.** A message holding two
- *   mentions ("this morning vs yesterday morning") fills nothing: which one a
- *   call means is the model's to say, through the quote. A mention whose
- *   reading is still open (the person has not chosen) is counted and fills
- *   nothing; a refused mention (its quote was not in the message) is not the
- *   person's words and is not counted. A `control` window (`time.window`, set
- *   in a UI) counts as one more mention with no quote.
- * - **Fill only what the model left out — exactly, else wider, never
- *   narrower.** Every argument of every form must be missing; the window goes
- *   into the first form that holds it exactly (`convert.ts` · `convertExact`),
- *   else the first that holds MORE (`convertWidened`: a whole day, the
- *   covering look-back — recorded with what it adds). No such form → the call
- *   is REFUSED, `no-form-holds` (`convert.ts` · `convertForTool`, the one
- *   answer): the tool's own rule never stands in for the person's window, so
- *   an assumed `1h` never silently reads a time the person did not ask about.
- * - **Refuse before dispatch what the tool cannot honestly read (step
- *   T5b).** A window — the person's to fill, or the model's sent — outside
- *   the tool's declared `direction`, wholly beyond its `retention` or wider
- *   than its `maxRange`; a range across days for a tool whose every form is a
- *   `day`; a window of the person's no form can read (`no-form-holds`); a
- *   sent wall time the zone skips. A window only partly beyond `retention`
- *   runs, marked. An open reading the tool can read in NO reading is refused
- *   too, and never asked.
- * - **A present window is never written over.** Bound by quote (the model's
- *   declared `user` quote names a recorded mention) or by value (the sent
- *   value, read back, IS a window of this turn); otherwise it runs as sent and
- *   is recorded `model-chosen` beside the person's window — a drill-down, a
- *   comparison and a baseline call are normal work.
- */
-import { type Conversion, type PeriodFacts, type PeriodForm, type TimeRefusal, type WidenedConversion } from './convert.js';
-import type { InstantText } from './instant.js';
-import type { TimeRange } from './range.js';
-import type { ZoneName } from './zone.js';
-export { isOpenForPerson, offeredLookback, pendingQuotesOf, readerWindowsOf, turnWindowsOf, windowToConvert, type ReaderWindows, type RefusedWindow, type TurnWindow, type TurnWindows, type WindowSource, } from './windows.js';
-import { type TurnWindow, type TurnWindows } from './windows.js';
-/** What the inputs layer knows about one call to a tool that declares period forms. */
-export interface CallToBind {
-    readonly args: Readonly<Record<string, unknown>>;
-    readonly forms: readonly PeriodForm[];
-    /** The argument is missing from the call (`arguments/declare.ts` · `isMissing`). */
-    readonly isMissing: (argument: string) => boolean;
-    /**
-     * Under declared sources: the quotes the model declared (`source: 'user'`)
-     * for this call's period arguments. Absent when the arm is off.
-     */
-    readonly quotes?: readonly string[];
-    /**
-     * The tool's declared facts (`direction`, `retention`, `maxRange`,
-     * `filtersToAsked`) — a call whose window breaks one is refused before
-     * dispatch (step T5b). Absent: nothing is checked.
-     */
-    readonly facts?: PeriodFacts;
-}
-/** The clock and zones a decision reads. */
-export interface BindContext {
-    readonly now: InstantText;
-    readonly zone: ZoneName;
-    readonly appZone?: ZoneName;
-    readonly granularityMs: number;
-}
-/** The decision for one call — see {@link callWindowOf}. */
-export type CallWindow = 
-/** The model left every period argument out and the turn's one window went into `form` exactly. */
-{
-    readonly how: 'filled';
-    readonly window: TurnWindow;
-    /** Exact, or — when no form holds the window exactly — WIDENED (it carries `sent` and `extra`). */
-    readonly conversion: Conversion | WidenedConversion;
-    /** Widened, and the tool declares `filtersToAsked`: it trims its rows to the asked window. */
-    readonly trimmedByTool?: true;
-    readonly partlyBeyondRetention?: true;
-}
-/** The sent window IS one of the turn's windows — named by the model's quote (`quote`) or equal in value (`value`). */
- | {
-    readonly how: 'bound';
-    readonly form: number;
-    readonly asked: TimeRange;
-    readonly window: TurnWindow;
-    readonly by: 'quote' | 'value';
-    readonly partlyBeyondRetention?: true;
-}
-/** The sent window differs from the person's: it runs as sent (§ 7.3, the v1 law). `person` when one window is the person's. */
- | {
-    readonly how: 'model-chosen';
-    readonly form: number;
-    readonly asked: TimeRange;
-    readonly person?: TurnWindow;
-    readonly partlyBeyondRetention?: true;
-}
-/** The sent window, and no window of the person's to compare it with. */
- | {
-    readonly how: 'model';
-    readonly form: number;
-    readonly asked: TimeRange;
-    readonly partlyBeyondRetention?: true;
-}
-/**
- * Refused before dispatch (step T5b): the window breaks one of the tool's
- * facts, spans days for a tool that reads one, or a sent wall time is one
- * the zone skips (`argument` names it). `asked` and `person` when known.
- */
- | {
-    readonly how: 'refused';
-    readonly refused: TimeRefusal;
-    readonly form?: number;
-    readonly asked?: TimeRange;
-    readonly person?: TurnWindow;
-    readonly argument?: string;
-}
-/** A period argument was sent, and no form reads the call's arguments back as a range. */
- | {
-    readonly how: 'unread';
-}
-/** The model left the period out and nothing was filled — why. */
- | {
-    readonly how: 'not-filled';
-    readonly why: 'no-window' | 'several-mentions' | 'open-reading';
-};
-/**
- * Which window one call carries (the module laws). Pure: the same call, forms
- * and windows always give the same decision.
- */
-export declare function callWindowOf(call: CallToBind, turn: TurnWindows, ctx: BindContext): CallWindow;
-/** The range a decision says the call asks for — the person's on a fill, the sent one otherwise. */
-export declare function askedRangeOf(decision: CallWindow): TimeRange | undefined;
-//# sourceMappingURL=bind.d.ts.map

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

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

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

@@ -1,114 +0,0 @@
-/**
- * core/time/check — the result checks (time design § 9.2, § 9.4, § 9.6, step T8).
- *
- * Pattern: one pure check per judged call, over what the record already holds
- *          — the call's `call-window` row (what the call asked, and the
- *          person's window beside it), its `call` row (the clock at
- *          dispatch), the periods its result declared, and the tool's facts —
- *          and one pure read over the turn's wall-clock sources. None reads
- *          words; none reads a period's offset as a clock.
- * Role:    core/ leaf (the time layer). Imports `instant.ts`, `range.ts`,
- *          `convert.ts` and the row types of `rows.ts`. Asked by the results
- *          layer (`results/subflow.ts` · `checkPeriods`), which files the
- *          answer on the call's `period` row (`coverage/period.ts` ·
- *          `PeriodRow`), and by the limits block (`coverage/period.ts` ·
- *          `periodCheckLine`, `clockLines`).
- * Emits:   N/A.
- *
- * ## Differs from asked — ONE check for narrower, wider and shifted (§ 9.2)
- *
- * The range the call asked for is compared with the range it READ, and two
- * lists come back: `missing` (asked but not read — a narrower read, or the
- * front of a shifted one) and `extra` (read but not asked — a wider read, or
- * the tail of a shifted one). What was read, first found wins:
- *
- * | Source | The read |
- * |--------|----------|
- * | `declared` | the result's own `period.queried` — inclusive at both ends, read back as `[from, to + step)`, `step` the tool's `granularity` (else 1 ms; § 3.3). Several declared: each is a read |
- * | `sent` | a widened fill the tool does not trim — the `call-window` row's `sent` |
- * | `shifted` | a look-back that ran as sent after the clock moved past the tool's step — the asked range moved by the `call` row's `drift.byMs` |
- * | `asked` | nothing says otherwise — the read IS the asked range (a fill, a binding, a redrawn look-back, a widened fill the tool trims) |
- *
- * Against what: the call's `asked` range — EXCEPT for a window the model
- * chose (`how: 'model-chosen'`), which is compared with the person's window
- * (§ 9.3: claims about the person's window are then "not sure"). A call with
- * neither — refused, not filled, unread — is not compared.
- *
- * Two differences are not differences: a piece no longer than one
- * millisecond (a closed end read as open — `[now − L, now]` against
- * `[now − L, now)`), and § 7.4's first row — a call that SENT a look-back
- * (`drift.ts` · `sentLookback`), with no drift recorded (the dispatch was
- * within the step), whose declared read has the asked length and moved LATER
- * by no more than the tool's step (one minute when none): the tool evaluated
- * the look-back on its own clock, a little after `now`, and that read IS the
- * asked range. Nothing else moves: a read moved EARLIER, a read of a window
- * sent as bounds, or a look-back with a recorded drift is compared as read —
- * its `missing` stands, and the answer is "not sure" (§ 9.2).
- *
- * ## Retention (§ 9.4)
- *
- * `beyondRetention` — the call was refused before dispatch because the window
- * was wholly older than the source keeps, or its read lies wholly before
- * `now − retention`. `partlyBeyondRetention` — the read starts before that
- * edge and ends after it (the result's `held` decides `partly-held`).
- *
- * ## Clocks (§ 9.6)
- *
- * A dataset whose declared time axis names a `zone` holds wall times in that
- * zone — a wall-clock source. {@link clocksDiffer} names the sources and zones
- * when two sources of one answer declare different zones: a label only, every
- * comparison is done on instants. A period's offset (`Z`, `-07:00`) is a
- * spelling of an instant, never a clock, and is never read here.
- *
- * @example
- * ```ts
- * periodTimeCheck({
- *   window: { how: 'filled', asked: { from: '2026-10-02T15:40:00Z', to: '2026-10-09T15:40:00Z' } },
- *   declared: [{ from: '2026-10-07T15:40:00Z', to: '2026-10-09T15:39:59.999Z' }], // clamped to 2 days
- *   now: '2026-10-09T15:40:00Z',
- * })?.differs?.missing; // [{ from: '2026-10-02T15:40:00Z', to: '2026-10-07T15:40:00Z' }]
- * ```
- */
-import { type InstantText } from './instant.js';
-import { type InclusiveSpan, type TimeRange } from './range.js';
-import { type PeriodFacts, type PeriodForm } from './convert.js';
-import type { CallDrift, CallWindowRow } from './rows.js';
-export { clocksDiffer, distinctSources, isPeriodDiffers, isShifted, type ClocksDiffer, type PeriodDiffers, type ReadSource, type SourceClock, } from './checkRecord.js';
-import type { PeriodDiffers } from './checkRecord.js';
-/** The time layer's result checks on one call — each key present only when it holds. */
-export interface PeriodTimeCheck {
-    readonly differs?: PeriodDiffers;
-    /** `period-shifted` (§ 7.4): the look-back ran as sent, `byMs` after the turn's `now`. */
-    readonly shifted?: {
-        readonly byMs: number;
-    };
-    /** `period-beyond-retention` (§ 9.4). */
-    readonly beyondRetention?: true;
-    /** `partly-beyond-retention` (§ 9.4). */
-    readonly partlyBeyondRetention?: true;
-}
-/** What one call's check reads — every field off a row or a declaration. */
-export interface PeriodCheckInput {
-    /** The call's `call-window` row — absent when the tool declares no forms. */
-    readonly window?: Pick<CallWindowRow, 'how' | 'form' | 'asked' | 'person' | 'sent' | 'trimmedByTool' | 'partlyBeyondRetention' | 'refused'>;
-    /** The call's `call` row's `drift`. */
-    readonly drift?: CallDrift;
-    /** The `queried` span of every period the call's result declared (inclusive ends). */
-    readonly declared?: readonly InclusiveSpan[];
-    readonly facts?: PeriodFacts;
-    /** The tool's period forms — with the window's `form`, whether the call sent a look-back (§ 7.4). */
-    readonly forms?: readonly PeriodForm[];
-    /** The turn's clock `now`. */
-    readonly now: InstantText;
-}
-/** The parts of `asked` not read, and the parts read not asked. */
-export declare function rangeDifference(asked: TimeRange, read: readonly TimeRange[]): {
-    readonly missing: TimeRange[];
-    readonly extra: TimeRange[];
-} | undefined;
-/**
- * The time layer's result checks on one call (§ 9.2, § 7.4, § 9.4) —
- * `undefined` when none holds, so an unremarkable call's row gains nothing.
- */
-export declare function periodTimeCheck(input: PeriodCheckInput): PeriodTimeCheck | undefined;
-//# sourceMappingURL=check.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../../../../src/core/time/check.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsEG;AAEH,OAAO,EAA2B,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AACzE,OAAO,EAA2B,KAAK,aAAa,EAAE,KAAK,SAAS,EAAE,MAAM,YAAY,CAAC;AAEzF,OAAO,EAA+B,KAAK,WAAW,EAAE,KAAK,UAAU,EAAE,MAAM,cAAc,CAAC;AAE9F,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAQ1D,OAAO,EACL,YAAY,EACZ,eAAe,EACf,eAAe,EACf,SAAS,EACT,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,UAAU,EACf,KAAK,WAAW,GACjB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,aAAa,EAAc,MAAM,kBAAkB,CAAC;AAElE,wFAAwF;AACxF,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,OAAO,CAAC,EAAE,aAAa,CAAC;IACjC,0FAA0F;IAC1F,QAAQ,CAAC,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IAC7C,yCAAyC;IACzC,QAAQ,CAAC,eAAe,CAAC,EAAE,IAAI,CAAC;IAChC,yCAAyC;IACzC,QAAQ,CAAC,qBAAqB,CAAC,EAAE,IAAI,CAAC;CACvC;AAED,4EAA4E;AAC5E,MAAM,WAAW,gBAAgB;IAC/B,6EAA6E;IAC7E,QAAQ,CAAC,MAAM,CAAC,EAAE,IAAI,CACpB,aAAa,EACX,KAAK,GACL,MAAM,GACN,OAAO,GACP,QAAQ,GACR,MAAM,GACN,eAAe,GACf,uBAAuB,GACvB,SAAS,CACZ,CAAC;IACF,uCAAuC;IACvC,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,CAAC;IAC3B,sFAAsF;IACtF,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,aAAa,EAAE,CAAC;IAC7C,QAAQ,CAAC,KAAK,CAAC,EAAE,WAAW,CAAC;IAC7B,qGAAqG;IACrG,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,UAAU,EAAE,CAAC;IACvC,8BAA8B;IAC9B,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAC;CAC3B;AA8CD,mEAAmE;AACnE,wBAAgB,eAAe,CAC7B,KAAK,EAAE,SAAS,EAChB,IAAI,EAAE,SAAS,SAAS,EAAE,GACzB;IAAE,QAAQ,CAAC,OAAO,EAAE,SAAS,EAAE,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,SAAS,EAAE,CAAA;CAAE,GAAG,SAAS,CAS5E;AA+GD;;;GAGG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,gBAAgB,GAAG,eAAe,GAAG,SAAS,CAWpF"}

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

@@ -1,75 +0,0 @@
-/**
- * core/time/checkRecord — the record half of the result checks (time design
- * § 9.2, § 9.6, step T8): the shapes a `period` row carries
- * (`PeriodDiffers`, `ReadSource`), the checkpoint door's tests for them
- * (`isPeriodDiffers`, `isShifted`), and the two reads over the turn's
- * wall-clock sources (`distinctSources`, `clocksDiffer`).
- *
- * Pattern: pure shapes and guards; no conversion, no drift, no clock.
- * Role:    split from `check.ts` BY FILE for the synchronous doors — the
- *          checkpoint door's row test (`coverage/period.ts` ·
- *          `periodRowIsWellFormed`) is on every agent's graph, and a bundler
- *          places a whole file there — so this file imports only
- *          `instant.ts` and the range and zone types (the optional-family
- *          law, `test/lib/trace-toolpack/browserGraph.test.ts`). `check.ts`
- *          re-exports every public name.
- * Emits:   N/A.
- *
- * @example
- * ```ts
- * clocksDiffer([
- *   { toolName: 'orders', zone: 'America/New_York' },
- *   { toolName: 'tickets', zone: 'Europe/Berlin' },
- * ]); // { tools: ['orders', 'tickets'], zones: ['America/New_York', 'Europe/Berlin'] }
- * ```
- */
-import type { TimeRange } from './range.js';
-import type { ZoneName } from './zone.js';
-/** Where a check's read range came from — see the module table. */
-export type ReadSource = 'declared' | 'sent' | 'shifted' | 'asked';
-/**
- * `period-differs-from-asked` (§ 9.2): the range compared against, what was
- * read, and the two lists — each piece half-open, in time order, spelled in
- * UTC. At least one list is non-empty (an empty check is not filed).
- */
-export interface PeriodDiffers {
-    /** `asked` — the call's asked range; `person` — the person's window, for a window the model chose. */
-    readonly against: 'asked' | 'person';
-    /** The range compared against. */
-    readonly asked: TimeRange;
-    /** What the call read — one range per declared period, else one. */
-    readonly read: readonly TimeRange[];
-    readonly source: ReadSource;
-    /** The step a declared inclusive end was read back with (§ 3.3) — `source: 'declared'` only. */
-    readonly stepMs?: number;
-    /** Asked but not read. */
-    readonly missing: readonly TimeRange[];
-    /** Read but not asked. */
-    readonly extra: readonly TimeRange[];
-}
-/** A dataset of one call whose declared time axis names a zone — a wall-clock source. */
-export interface SourceClock {
-    readonly toolName: string;
-    readonly zone: ZoneName;
-}
-/** `clocks-differ` (§ 9.6): the wall-clock sources of one answer, when they declare different zones. */
-export interface ClocksDiffer {
-    readonly tools: readonly string[];
-    readonly zones: readonly ZoneName[];
-}
-/**
- * The wall-clock sources of one answer, one per tool and zone in the order
- * met — the limits block names each. Fresh plain objects.
- */
-export declare function distinctSources(sources: readonly SourceClock[]): SourceClock[];
-/**
- * `clocks-differ` (§ 9.6) — the tools and zones when the wall-clock sources
- * of one answer declare more than one zone; `undefined` otherwise. A label
- * only: it changes no standing, and every comparison is made on instants.
- */
-export declare function clocksDiffer(sources: readonly SourceClock[]): ClocksDiffer | undefined;
-/** The checkpoint door's test for a row's {@link PeriodDiffers}. */
-export declare function isPeriodDiffers(value: unknown): value is PeriodDiffers;
-/** The checkpoint door's test for a row's `shifted`. */
-export declare function isShifted(value: unknown): boolean;
-//# sourceMappingURL=checkRecord.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"checkRecord.d.ts","sourceRoot":"","sources":["../../../../src/core/time/checkRecord.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAI1C,mEAAmE;AACnE,MAAM,MAAM,UAAU,GAAG,UAAU,GAAG,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC;AAEnE;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,sGAAsG;IACtG,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,QAAQ,CAAC;IACrC,kCAAkC;IAClC,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;IAC1B,oEAAoE;IACpE,QAAQ,CAAC,IAAI,EAAE,SAAS,SAAS,EAAE,CAAC;IACpC,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;IAC5B,gGAAgG;IAChG,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,0BAA0B;IAC1B,QAAQ,CAAC,OAAO,EAAE,SAAS,SAAS,EAAE,CAAC;IACvC,0BAA0B;IAC1B,QAAQ,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,CAAC;CACtC;AAED,yFAAyF;AACzF,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;CACzB;AAED,wGAAwG;AACxG,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,KAAK,EAAE,SAAS,QAAQ,EAAE,CAAC;CACrC;AAID;;;GAGG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,SAAS,WAAW,EAAE,GAAG,WAAW,EAAE,CAU9E;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,SAAS,WAAW,EAAE,GAAG,YAAY,GAAG,SAAS,CAKtF;AAaD,oEAAoE;AACpE,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,aAAa,CAiBtE;AAED,wDAAwD;AACxD,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAMjD"}

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

@@ -1,212 +0,0 @@
-/**
- * core/time/clock — the run clock: a declared, recorded input, never a hidden read.
- *
- * Pattern: normalize-or-refuse at a boundary (`core/runInput.ts`'s shape): the
- *          app's `.time({ zone })` and the run's `time: { now, zone, window }`
- *          are read here into one {@link TimeClock}, or refused by name.
- * Role:    core/ leaf (the time layer's one owner). Imports `instant.ts`,
- *          `zone.ts`, `range.ts`, `reader.ts` (the reader's check) and
- *          `resolve.ts` (the policy's) only. The Agent reads the two inputs
- *          (`Agent.run`, `Agent.resume`); seed stamps the clock once per turn
- *          (`rows.ts` · `ClockRow`); the ToolCalls resume door compares a
- *          resume's `time` with the kept clock ({@link clockChange}).
- * Emits:   N/A.
- *
- * ## The laws (time design § 4)
- *
- * - **The zone is per run; the builder's is a fallback.** The run's
- *   `time.zone` wins, `.time({ zone })` is used when the run names none, and
- *   with neither the zone is UNKNOWN (G15) — never the server's zone, never a
- *   guess: the clock records `zoneSource: 'unknown'` and spells instants in
- *   {@link UNKNOWN_ZONE_SPELLING} (UTC), every reading of the person's words
- *   waits on their zone (it is asked first), and the zone they answer holds
- *   for the turns after it (`zoneSource: 'answered'`).
- * - **`now` is the app's, else the turn's start** — admitted as
- *   `nowSource: 'default'`, like any default nobody chose.
- * - **Frozen across a pause.** The clock is written once per turn. A resume
- *   that passes a different `time` keeps the frozen clock and records what was
- *   passed ({@link clockChange}); it is not refused, because an app that
- *   passes the current time on every call is doing nothing wrong.
- * - **A window set in a UI is a run input** (`time.window`), recorded with
- *   `source: 'control'` — the person's own typed value, never filed as an
- *   answer to an ask.
- *
- * @example
- * ```ts
- * const run = readRunTime({ now: '2026-10-09T15:40:00Z', zone: 'America/Los_Angeles' });
- * const draft = draftClock(run.value, readTimeOptions({}).value!);
- * // { now: '2026-10-09T15:40:00Z', zone: 'America/Los_Angeles', zoneSource: 'run' }
- * completeClock(draft as ClockDraft, Date.parse('2026-10-09T15:40:02Z'));
- * // { now: '2026-10-09T15:40:00Z', nowSource: 'app', zone: 'America/Los_Angeles', zoneSource: 'run' }
- * ```
- */
-import { type InstantText } from './instant.js';
-import { type TimeRange } from './range.js';
-import { type ZoneName } from './zone.js';
-import { type TimeReader } from './reader.js';
-import { type TimePolicy } from './resolveRecord.js';
-import { type TimeAskMessages } from './ask.js';
-/** The run's clock, stamped once per turn (time design § 4). */
-export interface TimeClock {
-    /** The anchor for this turn — the app's `now`, else the turn's start. */
-    readonly now: InstantText;
-    /** The app passed `now`, or the library took the turn's start. */
-    readonly nowSource: 'app' | 'default';
-    /**
-     * The person's zone for this run — an IANA name. Under `zoneSource:
-     * 'unknown'` it is `'UTC'`: the zone instants are SPELLED in, never the
-     * person's.
-     */
-    readonly zone: ZoneName;
-    /**
-     * The run's `time.zone`, else the `.time({ zone })` fallback; with neither,
-     * the zone the person answered in an earlier turn of this conversation
-     * (`'answered'`), else `'unknown'` (G15).
-     */
-    readonly zoneSource: 'run' | 'builder' | 'answered' | 'unknown';
-}
-/**
- * The zone a clock with no known zone spells its instants in (G15) — named
- * as unknown wherever it is shown, never read as the person's.
- */
-export declare const UNKNOWN_ZONE_SPELLING: string;
-/**
- * The run's time input — `agent.run({ message, time })`, or the options bag of
- * `run`, `followUp`, `resume` and `resumeOnError`. Every key is optional; a
- * run with no zone here needs the builder's fallback.
- *
- * @example
- * ```ts
- * await agent.run({ message: 'errors since 8?', time: { now: sentAt, zone: 'America/Los_Angeles' } });
- * ```
- */
-export interface RunTime {
-    /**
-     * The turn's anchor — the MESSAGE's time, so a replay or a late resume
-     * reads "yesterday" the same way. An ISO 8601 instant with a zone (upper
-     * case `T` and `Z`, no leap second), or a `Date`. Omitted: the turn's start,
-     * recorded `nowSource: 'default'`.
-     */
-    readonly now?: string | Date;
-    /** The person's IANA zone for this run (`'America/Los_Angeles'`). Never an abbreviation. */
-    readonly zone?: string;
-    /**
-     * A window set in a UI — a brushed chart range, a range picker — as a
-     * half-open `{ from, to }` of instants. Recorded with `source: 'control'`.
-     */
-    readonly window?: TimeRange;
-}
-/** The builder's `.time(options)` — the fallback zone, the reader and its policy (time design § 11). */
-export interface TimeOptions {
-    /**
-     * The fallback zone for a run that names none. Omitted with no run zone
-     * either: the zone is unknown — never the server's — and the person is
-     * asked it before any time they wrote is read (G15).
-     */
-    readonly zone?: string;
-    /**
-     * The strategy that reads the person's words into time parts (`TimeReader`).
-     * No default: without one, the person's words are not read — no
-     * `time-reading` row is filed.
-     */
-    readonly reader?: TimeReader;
-    /**
-     * How the library picks among a reading's candidates (needs `reader`).
-     * `dateOrder` (default `'ask'`): a numeric date's orders become choices,
-     * or the one order your people write (`'MDY'`, `'DMY'`, `'YMD'`), recorded
-     * as assumed. `year` (default `'ask'`): a date said without a year is
-     * asked, or `'current'` — the clock's year, recorded as assumed.
-     */
-    readonly policy?: {
-        readonly dateOrder?: TimePolicy['dateOrder'];
-        readonly year?: TimePolicy['year'];
-    };
-    /**
-     * Your words for the time ask (`defaultTimeAskMessages` keys → sentence):
-     * the reason a refused time answer is re-asked with, the ask's questions,
-     * the label on a reading to confirm. A key you leave out keeps the default.
-     */
-    readonly messages?: Partial<TimeAskMessages>;
-}
-/** {@link RunTime} as read: every value checked and kept as written, a `Date` spelled in UTC. */
-export interface ReadRunTime {
-    readonly now?: InstantText;
-    readonly zone?: ZoneName;
-    readonly window?: TimeRange;
-}
-/** {@link TimeOptions} as read — the policy's defaults filled in when a reader is armed. */
-export interface ReadTimeOptions {
-    readonly zone?: ZoneName;
-    readonly reader?: TimeReader;
-    readonly policy?: TimePolicy;
-    /** The app's catalog overrides — every key one the catalog has. */
-    readonly messages?: Partial<TimeAskMessages>;
-}
-/** What a turn's clock is before seed knows the turn's start. */
-export interface ClockDraft {
-    readonly now?: InstantText;
-    readonly zone: ZoneName;
-    /** `'unknown'`: neither the run nor the builder named a zone — `zone` is the UTC spelling. */
-    readonly zoneSource: 'run' | 'builder' | 'unknown';
-    readonly window?: TimeRange;
-}
-/** A read answer: the value, or a problem named in words. */
-export type Read<T> = {
-    readonly value: T;
-} | {
-    readonly problem: string;
-};
-/**
- * The run's `time` input, checked. `undefined` reads as "nothing passed".
- * Refused, by name: a non-object, an unknown key, a zone that is not an IANA
- * name, a `now` that is not an instant with a zone, a `window` that is not two
- * strict instants with `from` before `to`.
- */
-export declare function readRunTime(value: unknown): Read<ReadRunTime | undefined>;
-/**
- * The builder's `.time(options)`, checked. `undefined` reads as `{}` — the
- * layer armed with no fallback zone, so every run names its own.
- */
-export declare function readTimeOptions(value: unknown): Read<ReadTimeOptions>;
-/**
- * The turn's clock as far as the run's inputs decide it. With no zone from
- * the run or the builder the zone is UNKNOWN (G15): `zoneSource: 'unknown'`,
- * instants spelled in {@link UNKNOWN_ZONE_SPELLING} — never the server's
- * zone, never a guess (seed reads a zone the person answered in an earlier
- * turn, `stages/timeLayer.ts` · `stampClock`).
- */
-export declare function draftClock(run: ReadRunTime | undefined, options: ReadTimeOptions): ClockDraft;
-/**
- * The clock, once the turn's start is known: `now` is the app's, else that
- * start. `answeredZone` — the zone the person answered in an earlier turn —
- * is read only when the draft's zone is unknown, and is then the turn's zone
- * (`zoneSource: 'answered'`).
- */
-export declare function completeClock(draft: ClockDraft, turnStartMs: number, answeredZone?: ZoneName): TimeClock;
-/** What a resume passed that differs from the kept clock, and the kept values it would have replaced. */
-export interface ClockChange {
-    readonly passed: ReadRunTime;
-    readonly kept: {
-        readonly now: InstantText;
-        readonly zone: ZoneName;
-        readonly window?: TimeRange;
-    };
-}
-/**
- * The difference between a resume's `time` and the turn's frozen clock, or
- * `undefined` when every value passed equals the kept one (a key not passed
- * is no difference). `now` compares as text: a resume passing the same
- * instant in another spelling is recorded, because the record keeps spellings.
- *
- * @example
- * ```ts
- * clockChange({ now: '2026-10-09T16:10:00Z' }, { now: '2026-10-09T15:40:00Z', zone: 'UTC' });
- * // { passed: { now: '2026-10-09T16:10:00Z' }, kept: { now: '2026-10-09T15:40:00Z', zone: 'UTC' } }
- * ```
- */
-export declare function clockChange(passed: ReadRunTime, kept: {
-    readonly now: InstantText;
-    readonly zone: ZoneName;
-    readonly window?: TimeRange;
-}): ClockChange | undefined;
-//# sourceMappingURL=clock.d.ts.map

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

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