react-semaphor 0.1.545 → 0.1.546

package/dist/types/lib/utils/field-availability-context.d.ts

@@ -0,0 +1,25 @@
+import { TCard } from '../types/common-types.js';
+import { AutoJoinMetadata } from '../types/query-types.js';
+import { JoinabilityMapResponse } from '../types/semantic-types.js';
+import { FieldStateContext } from './field-state-calculator.js';
+/**
+ * Everything `calculateFieldState` needs about a visual, except the
+ * selected fields (which differ per call). Built by ONE function so the
+ * field list, the click gate, the drop gate, and the matrix editor judge
+ * the same card from the same facts: the same join plan (the authored
+ * one, which is also right for matrix cards), the same auto-resolved
+ * base, the same relationship map, aliases, labels, mode, and data-source
+ * anchor. A caller that assembles these by hand will eventually disagree
+ * with the others; do not.
+ */
+export type FieldAvailabilityContext = Omit<FieldStateContext, 'selectedFields'> & {
+    /** The semantic domain the card reads, when any. */
+    semanticDomainId?: string;
+};
+export declare function buildFieldAvailabilityContext(input: {
+    card: Pick<TCard, 'type' | 'config' | 'dataSource'> | null | undefined;
+    joinabilityData?: JoinabilityMapResponse | null;
+    autoJoinMetadata?: AutoJoinMetadata;
+    /** Labels the caller knows from elsewhere (entity groups); catalog labels win. */
+    extraDatasetLabels?: Record<string, string>;
+}): FieldAvailabilityContext;

package/dist/types/lib/utils/field-placement.d.ts

@@ -0,0 +1,96 @@
+import { TCard, TCardPreferences } from '../types/common-types.js';
+import { CardConfig, ContainerId, Field } from '../types/explorer-types.js';
+import { MatrixCardCatalog } from '../matrix-table/matrix-card-adapter.js';
+import { MatrixEditorChange } from '../matrix-table/matrix-editor.js';
+import { FieldAvailabilityContext } from './field-availability-context.js';
+import { FieldStateResult } from './field-state-calculator.js';
+/**
+ * Field placement: the one rule for putting a field on a shelf.
+ *
+ * Every entry point (drop, move, reorder, click) and the drag preview call
+ * `evaluateFieldPlacement`; only `placeField` in `useFieldManagement` commits
+ * its outcome. The rules restate today's drag behavior per placement kind; see
+ * docs/implementation-plans/shelf-drop-placement/PLAN.md, "Placement rules".
+ *
+ * Evaluation is side-effect-free during the call: no id minting, store access,
+ * notifications, clock or random reads. New ids arrive in the context.
+ */
+export type ShelfZone = Exclude<ContainerId, 'source'>;
+export declare const SHELF_ZONES: readonly ShelfZone[];
+export type FieldPlacement = {
+    /** The field-list field, or the pill being moved. */
+    field: Field;
+    /** 'source' is the field list. */
+    from: ContainerId;
+    to: ShelfZone;
+    /** Pill to insert in front of; absent means the end. */
+    beforeId?: string;
+};
+export type FieldPlacementKind = 'add' | 'move' | 'copy-to-sort' | 'reorder';
+export type FieldPlacementNotice = {
+    kind: 'join-required';
+    fieldState?: FieldStateResult;
+} | {
+    kind: 'invalid-field-type';
+    reason: string;
+} | {
+    kind: 'already-on-shelf';
+    zone: ShelfZone;
+} | {
+    kind: 'sort-needs-shelf-field';
+} | {
+    kind: 'cannot-sort-from-pivot';
+} | {
+    kind: 'matrix-refused';
+    message: string;
+};
+export type FieldPlacementCommit = {
+    cardKind: 'standard';
+    config: CardConfig;
+    /** null leaves the card's preferences untouched. */
+    preferences: TCardPreferences | null;
+} | {
+    cardKind: 'matrix';
+    change: MatrixEditorChange;
+};
+export type FieldPlacementOutcome = {
+    kind: 'placed';
+    commit: FieldPlacementCommit;
+}
+/** A standard reorder onto its own slot. */
+ | {
+    kind: 'unchanged';
+} | {
+    kind: 'refused';
+    notice: FieldPlacementNotice;
+};
+export type FieldPlacementContext = {
+    availability: FieldAvailabilityContext;
+    /** Ignored for standard cards. */
+    matrixCatalog: MatrixCardCatalog;
+    /** A string exactly when `needsNewFieldId` is true. */
+    newFieldId: string | null;
+};
+/** Reserved id for standard-card previews. Never matches a minted id and never reaches the store. */
+export declare const PLACEMENT_PREVIEW_FIELD_ID = "__placement-preview__";
+/**
+ * Reserved id for Matrix previews. The Matrix spec validates instance ids as
+ * UUIDs, so the preview needs one; minted ids are random v4 UUIDs and never
+ * equal this fixed value. Never reaches the store.
+ */
+export declare const MATRIX_PLACEMENT_PREVIEW_ID = "00000000-0000-4000-8000-000000000000";
+/** The preview id for a card type. */
+export declare function placementPreviewId(cardType: TCard['type'] | undefined): string;
+export declare function classifyFieldPlacement(placement: Pick<FieldPlacement, 'from' | 'to'>): FieldPlacementKind;
+/** Standard cards: every kind except reorder. Matrix: only from the field list. */
+export declare function needsNewFieldId(cardType: TCard['type'] | undefined, placement: Pick<FieldPlacement, 'from' | 'to'>): boolean;
+/**
+ * A standard card's shelf as the editor shows it: stored fields with their
+ * shelf identity resolved and a label defaulted from the name.
+ */
+export declare function readStandardShelf(config: CardConfig | undefined, zone: ContainerId): Field[];
+export declare function evaluateStandardPlacement(card: TCard, placement: FieldPlacement, context: FieldPlacementContext): FieldPlacementOutcome;
+/** The one evaluation. Dispatches on card type. Side-effect-free. */
+export declare function evaluateFieldPlacement(card: TCard, placement: FieldPlacement, context: FieldPlacementContext): FieldPlacementOutcome;
+/** Preview text for the shelf header while a field hovers it. */
+export declare function placementNoticeReason(notice: FieldPlacementNotice, shelfLabel: string): string;

package/dist/types/lib/utils/field-state-calculator.d.ts

@@ -0,0 +1,161 @@
+import { Field, JoinPlan } from '../types/explorer-types.js';
+import { JoinabilityMap } from '../types/semantic-types.js';
+import { AutoJoinMetadata } from '../types/query-types.js';
+import { resolveFieldDatasetDependencies, FieldDatasetDependency } from './field-dependencies.js';
+import { getQualifiedEntityName } from './qualified-entity-name.js';
+export interface DatasetIdentityAlias {
+    name: string;
+    table?: string | null;
+    catalog?: string | null;
+    schema?: string | null;
+}
+/**
+ * Field draggability states for the query builder
+ *
+ * - **base**: Field is from the base dataset (first dataset selected)
+ * - **draggable**: Field has a direct relationship to base dataset (1-hop)
+ * - **indirect**: Field requires a multi-hop join (2-hop via intermediate dataset)
+ * - **setup**: A relationship exists but the engine will not use it on its
+ *   own (not set to auto-join). The user can fix this; until then the field
+ *   is blocked exactly like `unreachable`.
+ * - **unreachable**: No relationship path exists to this field's dataset
+ *
+ * Calculated fields take the worst state among the datasets they read from.
+ */
+export type FieldDraggableState = 'base' | 'draggable' | 'indirect' | 'setup' | 'unreachable'
+/**
+ * Nothing is on the shelves and the dataset is not one of the chart's
+ * data-source datasets. Not a fault to fix: the customer chose their
+ * datasets and this field reads another one. Blocked, with the path to
+ * using it (add the dataset) offered as information.
+ */
+ | 'absent';
+/** Per-dataset availability, attached to calculated-field results. */
+export interface FieldDependencyState {
+    /** Catalog dataset name. */
+    entityName: string;
+    /** Customer-facing dataset label. */
+    label: string;
+    state: FieldDraggableState;
+    /** Customer-facing sentence when the dataset is not simply available. */
+    reason?: string;
+}
+/**
+ * Result of field state calculation
+ */
+export interface FieldStateResult {
+    /** The calculated draggability state */
+    state: FieldDraggableState;
+    /** For indirect joins: the path through intermediate datasets */
+    joinPath?: string[];
+    /** `joinPath` as readers see it: dataset labels, in path order. */
+    joinPathLabels?: string[];
+    /** Short tooltip text explaining the state (row `title`). */
+    tooltip?: string;
+    /**
+     * Customer-facing explanation when the field cannot be added as-is.
+     * Precise: names the dataset and the actual problem.
+     */
+    reason?: string;
+    /** The one thing the user can do about `reason`, when there is one. */
+    action?: string;
+    /**
+     * Dataset labels that `reason` mentions, so the UI can set them off from
+     * the surrounding sentence (a chip) without parsing the text.
+     */
+    mentions?: string[];
+    /**
+     * Non-blocking caution from governed catalog metadata, for example a
+     * one-to-many join that can repeat an aggregate. Shown in the preview.
+     */
+    warning?: string;
+    /**
+     * Datasets a calculated field reads from, each with its own state.
+     * Undefined for base fields (their dataset is their group).
+     */
+    dependencies?: FieldDependencyState[];
+    /**
+     * False when availability could not be checked (relationship map still
+     * loading, or a dependency could not be traced). UI must not present
+     * such a field as verified-ready.
+     */
+    verified?: boolean;
+    /** Indicates if this field is already selected/in the query */
+    isSelected?: boolean;
+}
+/** States that block adding the field to the query. */
+export declare function isBlockedFieldState(state: FieldDraggableState | undefined): boolean;
+export interface FieldStateContext {
+    joinabilityMap: JoinabilityMap | null;
+    selectedFields: Field[];
+    joinPlan?: JoinPlan;
+    autoJoinMetadata?: AutoJoinMetadata;
+    baseEntityName?: string;
+    datasetAliases?: DatasetIdentityAlias[];
+    /**
+     * Whether the card reads from a semantic domain. Drives the fallback when
+     * `joinabilityMap` is null:
+     *   - true  -> the map is still loading: report `verified: false`.
+     *   - false -> physical datasets: reachability comes from the join plan.
+     *   - undefined (legacy callers) -> everything draggable, as before.
+     */
+    hasSemanticDomain?: boolean;
+    /** Customer-facing dataset labels keyed by dataset name. */
+    datasetLabels?: Record<string, string>;
+    /**
+     * The datasets the chart's data source lists (`DataSource.selectedEntities`),
+     * in order. When nothing is on the shelves yet, these ARE the chart's
+     * datasets: a calculated field's dependencies are judged against them,
+     * so the card talks about the dataset the customer actually picked
+     * instead of the calculation's own first input.
+     */
+    dataSourceEntities?: DatasetAnchorRef[];
+}
+/** Minimal entity reference the calculator needs to identify a dataset. */
+export type DatasetAnchorRef = Parameters<typeof getQualifiedEntityName>[0];
+/**
+ * Customer-facing words for a state, in one place. The row tag under a
+ * dependency and the title of the refusal toast both read from here.
+ */
+export declare function getFieldStateCopy(state: FieldDraggableState | undefined): {
+    /** Short tag beside a blocking dependency; null when nothing blocks. */
+    tag: string | null;
+    /** Title of the refusal toast. */
+    toastTitle: string;
+};
+/**
+ * Calculate the draggability state for a field in the query builder
+ *
+ * This determines whether a field can be dragged based on:
+ * - Current selected fields (what's already in the query)
+ * - Joinability map (what relationships exist between datasets)
+ * - For calculated fields: the datasets their inputs read from
+ *
+ * **Fallback behavior**:
+ * - No joinability map and no `hasSemanticDomain` flag: all fields draggable
+ *   (legacy callers, no restrictions)
+ * - No fields selected yet: base fields are draggable (first selection
+ *   establishes the base dataset); calculated fields are judged against the
+ *   data source's datasets when there are any, else against their own first
+ *   dataset
+ */
+export declare function calculateFieldState(field: Field, context: FieldStateContext): FieldStateResult;
+/** One data-source dataset's connection to the visual's base, for the Datasets panel. */
+export interface DataSourceConnection {
+    /** Dataset identity (name in semantic mode, qualified table in physical). */
+    entityName: string;
+    label: string;
+    state: FieldDraggableState;
+    reason?: string;
+    action?: string;
+    mentions?: string[];
+}
+/**
+ * How each selected dataset connects to the visual's base dataset, using
+ * the same identity, base cascade, and per-dataset evaluation as the field
+ * list. The Datasets panel shows this at selection time so the customer
+ * learns about an unconnected dataset before the first drag. Order and
+ * verdicts match `calculateFieldState` for a field of that dataset.
+ */
+export declare function describeDataSourceConnections(context: FieldStateContext): DataSourceConnection[];
+export { resolveFieldDatasetDependencies, type FieldDatasetDependency };

package/dist/types/lib/utils/qualified-entity-name.d.ts

@@ -0,0 +1,2 @@
+import { DatabaseEntityReference } from '../types/explorer-types.js';
+export declare function getQualifiedEntityName(target: Pick<DatabaseEntityReference, 'type' | 'database' | 'schema' | 'name'>): string;

package/dist/types/shared/analytics-protocol/field-provenance.d.ts

@@ -0,0 +1,89 @@
+/**
+ * A column's aggregate and label, written with what they record about where
+ * they came from, in one place (MCP dashboard editing, ledger V-18). Every
+ * producer writes through here (the editor's aggregate menu and rename, the
+ * governed compiler, the MCP's stated labels) and every reader asks here, so
+ * the value and its provenance always tell one story. Before, the editor's
+ * aggregate menu changed `aggregate` and `aggregateOrigin` but left the
+ * compiler's record (`effectiveAggregate`, `aggregateSource`) stale, and the
+ * compiler copied a catalog `aggregateOrigin: "default"` onto an aggregate the
+ * caller chose.
+ */
+export type MetricAggregateSource = 'semantic_model' | 'caller_override' | 'default_sum';
+/** A measure's aggregate and its provenance, as a saved column carries them (structural: any field type fits). */
+export type MetricAggregateProvenance<A extends string = string> = {
+    aggregate?: A;
+    aggregateOrigin?: 'default' | 'explicit';
+    semanticAggregate?: A;
+    effectiveAggregate?: A;
+    aggregateSource?: MetricAggregateSource;
+    /** The field's type, which decides the default aggregate (`defaultMetricAggregate`). */
+    dataType?: string;
+};
+/** A column's label and its provenance. */
+export type LabelProvenance = {
+    label?: string;
+    labelOrigin?: 'semantic' | 'override';
+    derivedLabel?: string;
+};
+/**
+ * The aggregate a measure gets when nobody chooses one, the one rule the
+ * editor (a field dropped on the measures), the governed compiler and every
+ * reader share: the semantic model's, else SUM for a number (or a type not
+ * known) and COUNT for anything else.
+ */
+export declare function defaultMetricAggregate<A extends string>(semanticAggregate: A | undefined, dataType?: string): A | 'SUM' | 'COUNT';
+/**
+ * The compiler's record of a measure's aggregate: the aggregate it runs, and
+ * whether that is the default or an override. Asking for SUM on a SUM measure
+ * is not an override (Analytics MCP focus 1.4b).
+ */
+export declare function metricAggregateRecord<A extends string>(input: {
+    aggregate: A;
+    semanticAggregate?: A;
+    dataType?: string;
+}): {
+    effectiveAggregate: A;
+    aggregateSource: MetricAggregateSource;
+};
+/**
+ * What to set on a measure for a new aggregate: the aggregate, whether
+ * someone chose it (`aggregateOrigin`), and, when the column carries the
+ * compiler's record, that record refreshed. A patch, for the editor's column
+ * updates; `withMetricAggregate` applies it.
+ */
+export declare function metricAggregatePatch<A extends string>(column: Pick<MetricAggregateProvenance<A>, 'semanticAggregate' | 'effectiveAggregate' | 'aggregateSource' | 'dataType'>, aggregate: A, origin: 'default' | 'explicit'): MetricAggregateProvenance<A>;
+/** A measure with a new aggregate and its provenance (`metricAggregatePatch`). */
+export declare function withMetricAggregate<T extends MetricAggregateProvenance>(column: T, aggregate: NonNullable<T['aggregate']>, origin: 'default' | 'explicit'): T;
+/**
+ * The aggregate a measure runs: `aggregate`, which the query builder reads;
+ * the compiler's record only when it is all the column has. Readers ask here,
+ * so a column saved with a stale record is still read as it runs.
+ */
+export declare function metricColumnAggregate<A extends string>(column: Pick<MetricAggregateProvenance<A>, 'aggregate' | 'effectiveAggregate'>): A | undefined;
+/**
+ * Whether someone chose a measure's aggregate rather than it being the
+ * default: the one reading of every stored shape. A column written here says
+ * so in `aggregateOrigin`; one saved before carries either the editor's mark,
+ * the compiler's record (an override, or a default the aggregate no longer
+ * equals because an editor change left the record stale), or neither (read as
+ * chosen, so a query states it).
+ */
+export declare function isMetricAggregateChosen(column: MetricAggregateProvenance): boolean;
+/** The keys an authored label sets together. */
+export declare const AUTHORED_LABEL_KEYS: readonly string[];
+/**
+ * What to set for a label someone wrote: an override, which the editor never
+ * refreshes as a generated label, and no `derivedLabel`, so the field display
+ * rule reads it as authored even when it repeats the synthesized text. A
+ * patch for the editor's column updates (`derivedLabel: undefined` drops it
+ * when saved); `withAuthoredLabel` applies it to a column.
+ */
+export declare function authoredLabelPatch(label: string): LabelProvenance;
+/** A column with a label someone wrote (`authoredLabelPatch`). */
+export declare function withAuthoredLabel<T extends LabelProvenance>(column: T, label: string): T;
+/**
+ * What to set for a generated label (an aggregate's "Average of Sales"): the
+ * label as a refreshable semantic hint, unless someone wrote the label.
+ */
+export declare function generatedLabelPatch(column: Pick<LabelProvenance, 'labelOrigin'>, label: string): LabelProvenance;

package/dist/types/shared/analytics-protocol/index.d.ts

@@ -28,6 +28,8 @@ export * from './relative-date-label.js';
 export * from './operation-temporal-state.js';
 export * from './aggregate-expression.js';
 export * from './measure-aggregation-profile.js';
+export * from './field-provenance.js';
+export * from './query-policies.js';
 export * from './analytics-refusal.js';
 export * from './visual-choice.js';
 /**

package/dist/types/shared/analytics-protocol/query-policies.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Small pure policies of how a query runs, shared by the governed compiler
+ * and the query builder (semaphor-app) and by whatever reads a saved card
+ * back (MCP dashboard editing, ledger V-19). Each was written once on the
+ * compiling side and again, inverted, on the reading side; a change to one
+ * copy would have broken the other silently. Grounding and SQL generation
+ * stay app-owned: these are the string and ordering rules only.
+ */
+/**
+ * The sort a query gets when it states none: the grouped date ascending;
+ * else, when something is grouped, the primary measure (the first when none
+ * is named) descending; else none.
+ */
+export declare function defaultQuerySort<T>(parts: {
+    groupedDate?: T;
+    measures: readonly T[];
+    grouped: boolean;
+    primaryMeasure?: T;
+}): {
+    target: T;
+    direction: 'asc' | 'desc';
+} | undefined;
+/** The saved condition operators that run a LIKE pattern. */
+export type SavedPatternOperator = 'contains' | 'startsWith' | 'endsWith' | 'like' | 'not like';
+export declare const SAVED_PATTERN_OPERATORS: ReadonlySet<string>;
+/** A LIKE wildcard: `%` or `_`. */
+export declare function hasLikeWildcard(value: string): boolean;
+/**
+ * The LIKE pattern a saved condition runs (the query builder's rule):
+ * `contains` matches anywhere, `startsWith` and `endsWith` at one end, and
+ * `like` and `not like` run the value as written.
+ */
+export declare function savedConditionPattern(operator: SavedPatternOperator, value: string): {
+    pattern: string;
+    negate: boolean;
+};
+/**
+ * The pattern a public `contains` filter runs (the compiler's rule): the
+ * value wrapped in `%...%`, unless it already holds a wildcard.
+ */
+export declare function containsFilterPattern(value: string): string;
+/**
+ * A saved pattern condition as the public `contains` / `not_contains` filter
+ * that runs the same pattern again, or undefined when none does (a pattern
+ * without a wildcard matches a value exactly). Checked against
+ * `containsFilterPattern` itself, so the reading can never drift from the
+ * compiler.
+ */
+export declare function statedPatternFilter(operator: SavedPatternOperator, value: string): {
+    operator: 'contains' | 'not_contains';
+    value: string;
+} | undefined;

package/dist/types/shared/analytics-protocol/time-window-schema.d.ts

@@ -160,7 +160,7 @@ export declare function semaphorTimeWindowSchemas(options?: {
         start: string;
         end: string;
     }>;
-    timeWindow: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
+    timeWindow: z.ZodUnion<readonly [z.ZodEffects<z.ZodObject<{
         kind: z.ZodOptional<z.ZodLiteral<"relative">>;
         unit: z.ZodEnum<["second", "minute", "hour", "day", "week", "month", "quarter", "year"]>;
         value: z.ZodNumber;

package/dist/types/shared/analytics-protocol/time-window.d.ts

@@ -1,4 +1,5 @@
-import { SemaphorRelativeTimeWindow, SemaphorTimeGrain } from './contracts.js';
+import { SemaphorCalendarTimeWindow, SemaphorRelativeTimeWindow, SemaphorTimeGrain, SemaphorTimeWindow } from './contracts.js';
+import { RelativeDateFilter } from './relative-date-filter.js';
 /** Units a calendar window ("this month", "previous quarter") can name. */
 export declare const SEMAPHOR_CALENDAR_TIME_WINDOW_UNITS: readonly ["day", "week", "month", "quarter", "year"];
 export declare const SEMAPHOR_CALENDAR_TIME_WINDOW_PERIODS: readonly ["this", "previous"];
@@ -11,3 +12,41 @@ export declare const SEMAPHOR_TIME_WINDOW_MAX_VALUE: Readonly<Record<SemaphorTim
  * latest available data; a saved card that should keep rolling states "now".
  */
 export declare function resolveTimeWindowAnchor(timeWindow: Pick<SemaphorRelativeTimeWindow, 'anchor'>): 'now' | 'latest_available';
+/** A rolling "last N units" window (`kind` "relative" or omitted). */
+export declare function isRelativeTimeWindow(timeWindow: SemaphorTimeWindow | null | undefined): timeWindow is SemaphorRelativeTimeWindow;
+/** A whole calendar period, such as this month or the previous quarter. */
+export declare function isCalendarTimeWindow(timeWindow: SemaphorTimeWindow | null | undefined): timeWindow is SemaphorCalendarTimeWindow;
+/**
+ * A window as a dashboard filter's default. Filter defaults run to now (the
+ * editor's presets and the filter runtime have no latest-data anchor), so a
+ * rolling window without an anchor is anchored at now, and one anchored to
+ * the latest available data is not a filter default (null), never quietly
+ * moved to now. The one conversion every writer and checker of a filter
+ * default uses.
+ */
+export declare function timeWindowToFilterDefault(timeWindow: SemaphorTimeWindow): RelativeDateFilter | null;
+/** A rolling week, month, quarter or year that includes the current, partial one: no filter preset holds it. */
+export declare function isPartialRollingPeriod(timeWindow: SemaphorTimeWindow): boolean;
+/**
+ * The time window a filter default states, the inverse of
+ * `timeWindowToFilterDefault`, so what an agent reads back is what it would
+ * write: the last N days with today (`between` days from 1-N to 0), complete
+ * periods, this or the previous period; a rolling window saved before is
+ * read as rolling. Null for any other stored default, such as `between` on
+ * whole weeks or months, which no time window states.
+ */
+export declare function filterDefaultToTimeWindow(meta: RelativeDateFilter): SemaphorTimeWindow | null;
+/**
+ * The relative date an agent time window persists as (plan D10, amended by
+ * analytics kernel K11), or null when it can't stay relative: absolute
+ * windows, second units, and complete minute or hour periods. A window
+ * anchored to the latest available data (an omitted anchor included) counts
+ * back from its own field's data anchor (`relativeTo: 'latest_data'`).
+ * `completeness` is the completeness the run used, when it was inferred.
+ * Moved from semaphor-app's query-spec-filters so a card's date window and a
+ * dashboard filter's default period convert through one owner (MCP dashboard
+ * editing, ledger P3-04).
+ */
+export declare function timeWindowToRelativeDateFilter(timeWindow: SemaphorTimeWindow, options?: {
+    completeness?: 'include_partial' | 'complete_periods';
+}): RelativeDateFilter | null;

package/dist/types/shared/assistant-context/saved-dashboard-context.d.ts

@@ -35,7 +35,9 @@ export declare function projectSavedDashboardContext(input: {
 /**
  * What a browser opening the saved dashboard at `place` sends with a message:
  * the context and, for an asked-about card, its replay fields, both from the
- * one snapshot (ledger P3-92). The regression set sends exactly this.
+ * one snapshot (ledger P3-92), and the dashboard it projected, which a person
+ * who may change it sends as `openDashboard` (Phase 7, D7-29). The regression
+ * set sends exactly this.
  */
 export declare function projectSavedDashboardTurn(input: {
     dashboard: TDashboard;
@@ -45,6 +47,7 @@ export declare function projectSavedDashboardTurn(input: {
 }): {
     context: AssistantContext;
     cardReplay?: AssistantCardReplayFields;
+    openDashboard: TDashboard;
 };
 /** The turn request's fields for an asked-about card: its request, or why it has none. */
 export type AssistantCardReplayFields = {

package/dist/types/shared/assistant-protocol/answer-text.d.ts

@@ -0,0 +1,20 @@
+import { AssistantPart } from './parts.js';
+/**
+ * Which of an answer's text is the answer (analytics agent Plan 1, P7-23):
+ * its last run of text, the text after the last step that more text follows.
+ * Text the model wrote before such a step ("Need the domain and fields.") is
+ * a working note: the transcript shows it while the assistant works, and not
+ * as the answer once more text follows a later step. An answer followed by a
+ * last query and nothing after it keeps its text, so no answer that wrote
+ * anything comes out empty. A step is a stage that reads data (a query, a
+ * lookup); a change to the dashboard, showing a result or asking the person a
+ * question is not one, so an answer written before its change stays the
+ * answer (P7-45). One rule for the transcript, the turn record and the eval.
+ */
+export type AnswerPartKind = 'text' | 'step' | 'other';
+/** The parts that are working notes: text before the last step that comes before the answer's last text. */
+export declare function workingNotesOf<T>(parts: readonly T[], kindOf: (part: T) => AnswerPartKind): ReadonlySet<T>;
+/** A stored part's kind for `workingNotesOf`. */
+export declare function storedPartKind(part: AssistantPart): AnswerPartKind;
+/** A stored answer's text: its text parts after the last step, a paragraph each. */
+export declare function answerTextOf(parts: readonly AssistantPart[]): string;