@mintplayer/ng-spark 22.17.0 → 22.19.0

package/types/mintplayer-ng-spark-models.d.ts

@@ -53,6 +53,16 @@ interface PersistentObject {
     name: string;
     objectTypeId: string;
     breadcrumb?: string;
+    /**
+     * Optimistic-concurrency token -- RavenDB's change vector for the document behind this object.
+     * The server stamps it on every `/po/load` and expects it back on update.
+     *
+     * ⚠️ The check is opt-in BY PRESENCE of this field. Dropping it does not fail loudly; it makes
+     * the save unconditional, so two people editing the same record both succeed and the second
+     * silently overwrites the first. That is what used to happen here: `SparkClient` round-tripped
+     * the token and got a 409, the browser did not and got last-write-wins, on the same endpoint.
+     */
+    etag?: string;
     attributes: PersistentObjectAttribute[];
     /** Per-row edit/delete affordances; undefined = fall back to type-level permissions. */
     can?: PersistentObjectPermissions;
@@ -552,6 +562,70 @@ interface StreamingErrorMessage {
 }
 type StreamingMessage = StreamingSnapshotMessage | StreamingPatchMessage | StreamingErrorMessage;
 
+/**
+ * Conversions between the wire format for a timestamp and what an `<input type="datetime-local">`
+ * or `<input type="date">` will accept.
+ *
+ * A `DateTimeOffset` in Spark means an **instant**. The wire carries a full ISO-8601 string with an
+ * offset (`2026-12-31T23:59:00-08:00`); an HTML date/time control speaks only bare local wall clock
+ * (`2026-12-31T23:59`). Neither end can consume the other's format, so both directions need
+ * converting, and the browser is deliberately the side that does it: its timezone rules are kept
+ * fresh by the operating system, while a container's are frozen at image build time.
+ *
+ * Assigning a wire value straight to a `datetime-local` input does not throw and does not warn -- the
+ * control simply renders **blank**, and saving the untouched form then writes that blank back.
+ */
+/**
+ * Parses a wire timestamp. Returns `null` for anything unusable, matching the contract of
+ * `parsedDate` / `queryCellValue` -- a bad value renders as empty rather than as `Invalid Date`.
+ */
+declare function parseWireDate(value: unknown): Date | null;
+/**
+ * Wire value -> the `yyyy-MM-ddTHH:mm` a `datetime-local` input needs, in the **viewer's** zone.
+ *
+ * The conversion is date-sensitive, not a fixed shift: a value is rendered using the zone's offset
+ * *on that value's own date*, so a timestamp in July and one in January convert differently in a
+ * zone that observes DST.
+ */
+declare function toDateTimeLocalInput(value: unknown): string;
+/** Wire value -> the `yyyy-MM-dd` a `date` input needs, in the viewer's zone. */
+declare function toDateInput(value: unknown): string;
+/**
+ * `yyyy-MM-ddTHH:mm` from the control -> a complete ISO-8601 string carrying the viewer's offset
+ * **for the entered date**.
+ *
+ * Building the `Date` from its parts rather than parsing the string is what makes this correct: it
+ * lets the browser apply its own timezone rules for that date, including DST. Using the *current*
+ * offset instead would be wrong for any value outside the present season -- entering a January date
+ * during summer would record an offset an hour off, and the stored instant would be an hour wrong.
+ *
+ * Across a DST discontinuity the browser resolves the wall clock itself, taking the offset in force
+ * before a fall-back and after a spring-forward. That is specified ECMAScript behaviour, and the
+ * server's conversion helper deliberately reproduces the same choice so the two cannot drift.
+ */
+declare function fromDateTimeLocalInput(local: unknown): string | null;
+/** `yyyy-MM-dd` from a `date` control -> an ISO string at local midnight with the viewer's offset. */
+declare function fromDateInput(local: unknown): string | null;
+/**
+ * Compares two wire timestamps **by instant**, which is what a `DateTimeOffset` means in Spark.
+ *
+ * Round-tripping a value through a date control legitimately rewrites its text -- a document holding
+ * `2026-12-31T23:59:00-08:00` comes back as `2027-01-01T08:59:00+01:00` from a viewer in Brussels --
+ * so a string comparison would mark every untouched date as edited and send a needless write on every
+ * save. Both of those name the same moment.
+ *
+ * Note this is the *opposite* of the trap on the server side, where `DateTimeOffset.Equals` compares
+ * the instant and silently hides a destroyed offset. Here comparing by instant is the correct thing:
+ * we are asking "did the user change this value", not "is the offset intact".
+ */
+declare function wireDatesEqual(a: unknown, b: unknown): boolean;
+/** True for the attribute data types that are edited through a native date/time control. */
+declare function isDateDataType(dataType: string | null | undefined): dataType is 'date' | 'datetime';
+/** Wire -> control, picking the right shape for the data type. */
+declare function toDateInputValue(dataType: string | null | undefined, value: unknown): string;
+/** Control -> wire, picking the right shape for the data type. */
+declare function fromDateInputValue(dataType: string | null | undefined, value: unknown): string | null;
+
 /**
  * Resolves an `EntityType` by its CLR type name (e.g. `"HR.Entities.Address"`).
  * Callers typically close over a list they already hold. `getEntityTypes()` is NOT cached --
@@ -629,6 +703,22 @@ declare function resolvedBreadcrumb(value: unknown, typeName?: string): string |
  * reference-query options page. Prefixed to avoid colliding with a real attribute name.
  */
 declare const AS_DETAIL_BREADCRUMBS_KEY = "__sparkBreadcrumbs";
+/**
+ * Reserved key under which a flattened row keeps the **wire** values of its date cells, keyed by
+ * attribute name.
+ *
+ * A date cell is edited through a native control that speaks only a bare local wall clock, so
+ * flattening converts the stored instant into the viewer's zone and saving converts it back. That
+ * round trip preserves the instant but necessarily rewrites the **offset** to the viewer's. For a
+ * cell the user actually edited that is correct — the offset is not business data. For one nobody
+ * touched it is pure loss: merely opening a row and saving would relabel a Seattle timestamp as a
+ * Brussels one.
+ *
+ * Keeping the original lets {@link dictToNestedPo} send back exactly what it was given whenever the
+ * instant is unchanged. Safe to carry for the same reason as the other reserved keys: the rebuild
+ * walks the entity type's attributes, never the dict's keys.
+ */
+declare const AS_DETAIL_ORIGINAL_DATES_KEY = "__sparkOriginalDates";
 /**
  * Whether a flattened-row key is one this module reserved rather than a model attribute.
  *
@@ -791,5 +881,5 @@ interface EvaluableAttribute {
  */
 declare function evaluateRules(attr: EvaluableAttribute, value: any): RuleFailure[];
 
-export { AS_DETAIL_BREADCRUMBS_KEY, AS_DETAIL_ROW_KEY, AS_DETAIL_SELF_BREADCRUMB_KEY, ELookupDisplayType, EReferenceDisplayType, ShowedOn, applyOverlay, currentLanguage, dictToNestedPo, evaluateRules, filterQueryActions, hasShowedOnFlag, isPersistentObject, isQueryRow, isReservedAsDetailKey, mergeRefreshValues, nestedPoToDict, nestedPoToDisplayRow, overlayFromResponse, parseSelectionRule, resolveTranslation, resolvedBreadcrumb, selectionModeFor, selfBreadcrumb, valueFor };
+export { AS_DETAIL_BREADCRUMBS_KEY, AS_DETAIL_ORIGINAL_DATES_KEY, AS_DETAIL_ROW_KEY, AS_DETAIL_SELF_BREADCRUMB_KEY, ELookupDisplayType, EReferenceDisplayType, ShowedOn, applyOverlay, currentLanguage, dictToNestedPo, evaluateRules, filterQueryActions, fromDateInput, fromDateInputValue, fromDateTimeLocalInput, hasShowedOnFlag, isDateDataType, isPersistentObject, isQueryRow, isReservedAsDetailKey, mergeRefreshValues, nestedPoToDict, nestedPoToDisplayRow, overlayFromResponse, parseSelectionRule, parseWireDate, resolveTranslation, resolvedBreadcrumb, selectionModeFor, selfBreadcrumb, toDateInput, toDateInputValue, toDateTimeLocalInput, valueFor, wireDatesEqual };
 export type { AttributeGroup, AttributeOverlay, AttributeTab, CustomActionDefinition, EntityAttributeDefinition, EntityPermissions, EntityType, EntityTypeResolver, EvaluableAttribute, LookupReference, LookupReferenceListItem, LookupReferenceValue, PersistentObject, PersistentObjectAttribute, PersistentObjectPermissions, ProgramUnit, ProgramUnitGroup, ProgramUnitsConfiguration, QueryColumn, QueryResult, QueryResultItem, QueryResultItemValue, RefreshOverlay, RefreshedOption, RetryActionPayload, RetryActionResult, RuleFailure, SparkCellColumn, SparkQuery, SparkQueryRenderMode, SparkQuerySortColumn, SparkRow, SparkSelectionMode, StreamingErrorMessage, StreamingMessage, StreamingPatchItem, StreamingPatchMessage, StreamingSnapshotMessage, TranslatedString, ValidationError, ValidationErrorResponse, ValidationRule };

package/types/mintplayer-ng-spark-pipes.d.ts

@@ -21,6 +21,29 @@ declare class InputTypePipe implements PipeTransform {
     static ɵpipe: i0.ɵɵPipeDeclaration<InputTypePipe, "inputType", true>;
 }
 
+/**
+ * Parses a wire value into a `Date`, or `null` when it is absent or unparseable.
+ *
+ * Exists so the detail page and the grid agree. The grid gets its `Date` from `queryCellValue`, which
+ * needs a cell and a column and so cannot be reused on a detail attribute; before this, the detail page
+ * had no parsing step at all and printed the raw ISO string — `2026-12-31T23:59:00-08:00` in a
+ * definition list, while the grid showed `01/01/2027, 08:59` for the same document.
+ *
+ * The parsing contract is deliberately identical to `queryCellValue`'s: `new Date(...)`, and an
+ * unparseable value yields `null` so the caller can fall back to its own text rather than rendering
+ * "Invalid Date".
+ *
+ * Note what `new Date(...)` does to an offset, because it is the whole reason this is a separate step:
+ * it collapses the value to an instant and forgets the offset it was written with. That is correct for
+ * display — a viewer wants the moment in their own zone — but it means a `Date` can never be the thing
+ * you reach for when you need the *originating* wall clock. Read that from the wire value instead.
+ */
+declare class ParsedDatePipe implements PipeTransform {
+    transform(value: unknown): Date | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ParsedDatePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ParsedDatePipe, "parsedDate", true>;
+}
+
 declare class AttributeValuePipe implements PipeTransform {
     transform(attrName: string, item: PersistentObject | null, entityType: EntityType | null, lookupRefOptions: Record<string, LookupReference>, allEntityTypes: EntityType[]): any;
     private formatAsDetailValue;
@@ -265,5 +288,5 @@ declare class QueryReferenceChipsPipe implements PipeTransform {
     static ɵpipe: i0.ɵɵPipeDeclaration<QueryReferenceChipsPipe, "queryReferenceChips", true>;
 }
 
-export { ArrayValuePipe, AsDetailCellValuePipe, AsDetailColumnsPipe, AsDetailDisplayValuePipe, AsDetailTypePipe, AttributeValuePipe, CanCreateDetailRowPipe, CanDeleteDetailRowPipe, CanEditDetailRowPipe, ErrorForAttributePipe, IconNamePipe, InlineRefOptionsPipe, InputTypePipe, LookupDisplayTypePipe, LookupDisplayValuePipe, LookupOptionsPipe, QueryCellValuePipe, QueryReferenceChipsPipe, RawAttributeValuePipe, ReferenceAttrValuePipe, ReferenceChipsPipe, ReferenceDisplayValuePipe, ReferenceLinkRoutePipe, ResolveTranslationPipe, RouterLinkPipe, TranslateKeyPipe };
+export { ArrayValuePipe, AsDetailCellValuePipe, AsDetailColumnsPipe, AsDetailDisplayValuePipe, AsDetailTypePipe, AttributeValuePipe, CanCreateDetailRowPipe, CanDeleteDetailRowPipe, CanEditDetailRowPipe, ErrorForAttributePipe, IconNamePipe, InlineRefOptionsPipe, InputTypePipe, LookupDisplayTypePipe, LookupDisplayValuePipe, LookupOptionsPipe, ParsedDatePipe, QueryCellValuePipe, QueryReferenceChipsPipe, RawAttributeValuePipe, ReferenceAttrValuePipe, ReferenceChipsPipe, ReferenceDisplayValuePipe, ReferenceLinkRoutePipe, ResolveTranslationPipe, RouterLinkPipe, TranslateKeyPipe };
 export type { AsDetailCellValue, ReferenceChip };

package/types/mintplayer-ng-spark-po-create.d.ts

@@ -1,5 +1,5 @@
 import * as _mintplayer_ng_spark_models from '@mintplayer/ng-spark/models';
-import { PersistentObject, EntityType, ValidationError } from '@mintplayer/ng-spark/models';
+import { PersistentObject, EntityType, RefreshOverlay, ValidationError } from '@mintplayer/ng-spark/models';
 import * as _angular_core from '@angular/core';
 import { Color } from '@mintplayer/ng-bootstrap';
 
@@ -13,6 +13,8 @@ declare class SparkPoCreateComponent {
     entityType: _angular_core.WritableSignal<EntityType | null>;
     type: _angular_core.WritableSignal<string>;
     formData: _angular_core.WritableSignal<Record<string, any>>;
+    /** Bound two-way to the form. See {@link getEditableAttributes}. */
+    refreshOverlay: _angular_core.WritableSignal<RefreshOverlay>;
     validationErrors: _angular_core.WritableSignal<ValidationError[]>;
     isSaving: _angular_core.WritableSignal<boolean>;
     private allEntityTypes;
@@ -20,6 +22,11 @@ declare class SparkPoCreateComponent {
     constructor();
     private onParamsChange;
     initFormData(): void;
+    /**
+     * ⚠️ Overlaid before filtering — same reason as <c>spark-po-edit</c>, and worse here: this list is
+     * the <em>only</em> source of the create payload, so an attribute a refresh hook revealed was not
+     * merely sent stale, it was absent from the new object entirely.
+     */
     getEditableAttributes(): _mintplayer_ng_spark_models.EntityAttributeDefinition[];
     onSave(): Promise<void>;
     onCancel(): void;

package/types/mintplayer-ng-spark-po-edit.d.ts

@@ -1,5 +1,5 @@
 import * as _mintplayer_ng_spark_models from '@mintplayer/ng-spark/models';
-import { PersistentObject, EntityType, ValidationError } from '@mintplayer/ng-spark/models';
+import { PersistentObject, EntityType, RefreshOverlay, ValidationError } from '@mintplayer/ng-spark/models';
 import * as _angular_core from '@angular/core';
 import { Color } from '@mintplayer/ng-bootstrap';
 
@@ -7,6 +7,7 @@ declare class SparkPoEditComponent {
     private readonly route;
     private readonly router;
     private readonly sparkService;
+    private readonly language;
     saved: _angular_core.OutputEmitterRef<PersistentObject>;
     cancelled: _angular_core.OutputEmitterRef<void>;
     colors: typeof Color;
@@ -15,6 +16,11 @@ declare class SparkPoEditComponent {
     type: string;
     id: string;
     formData: _angular_core.WritableSignal<Record<string, any>>;
+    /**
+     * Bound two-way to the form, which is where refreshes land. Read by
+     * {@link getEditableAttributes} so the save sees the object the user was actually shown.
+     */
+    refreshOverlay: _angular_core.WritableSignal<RefreshOverlay>;
     validationErrors: _angular_core.WritableSignal<ValidationError[]>;
     isSaving: _angular_core.WritableSignal<boolean>;
     private allEntityTypes;
@@ -22,7 +28,33 @@ declare class SparkPoEditComponent {
     constructor();
     private onParamsChange;
     initFormData(): void;
+    /**
+     * Resolves a nested AsDetail type by CLR name, for rebuilding the nested PO wire shape on save.
+     *
+     * ⚠️ <b>`detailTypes` first, catalogue second.</b> The catalogue from `/spark/types` is
+     * <b>Query-gated</b>, and an AsDetail row type usually has no rights of its own — nobody grants
+     * `Query/GateSettings`, because a gate is edited through the Repository that owns it. So the
+     * catalogue does not contain it, the resolver returned undefined, and the save quietly took the
+     * scalar branch: the attribute went out as a raw dict under `value` instead of a nested PO under
+     * `object`, the server could not map it, and `EntityMapper`'s conversion `catch` swallowed the
+     * failure. The save reported success and wrote nothing.
+     * <para>
+     * `detailTypes` is the parent's own copy of its row types, carried on the type definition for
+     * exactly this reason (#385 fixed the rendering half; this is the save half). It is gated on the
+     * parent's right, which is the right that governs editing the row anyway.
+     * </para>
+     */
     private resolveEntityType;
+    /**
+     * The attributes this page will read values from when it builds the save.
+     *
+     * ⚠️ <b>Overlaid before filtering, not after loading.</b> A refresh hook can reveal an attribute
+     * that was hidden when the object was loaded, and the ordinary reason it does so is that the
+     * attribute has just become required. Filtering on the loaded state left such an attribute out of
+     * both {@link initFormData} and the save payload, so the user filled in a field whose value was
+     * then dropped on the floor and refused by the server as missing — with no way out of the form.
+     * The overlay is the form's, bound two-way, so the two halves cannot drift again.
+     */
     getEditableAttributes(): _mintplayer_ng_spark_models.EntityAttributeDefinition[];
     onSave(): Promise<void>;
     onCancel(): void;

package/types/mintplayer-ng-spark-po-form.d.ts

@@ -56,6 +56,17 @@ declare class RefreshCoordinator {
     trigger(attributeName: string): Promise<void>;
 }
 
+/**
+ * A refresh a form embedded in another form is asking its host to issue on its behalf.
+ *
+ * `immediate` mirrors the distinction the host's own editors make: a discrete editor fires on
+ * change, free text only marks itself pending and fires on blur.
+ */
+interface NestedTriggerRequest {
+    /** The full path the server addresses, e.g. `Gate.ProjectMode`. */
+    path: string;
+    immediate: boolean;
+}
 declare class SparkPoFormComponent {
     private readonly sparkService;
     private readonly translations;
@@ -76,6 +87,18 @@ declare class SparkPoFormComponent {
     objectTypeId: _angular_core.InputSignal<string | undefined>;
     /** The id of the object being edited; absent for a create. */
     objectId: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Set when this form renders a single embedded AsDetail object inside a host form: the name of
+     * the attribute holding it, e.g. `"Gate"`. Presence of a prefix switches the form from issuing
+     * its own refreshes to reporting them upward, because an embedded object is not something the
+     * server can be asked about on its own — the request must describe, and be authorized against,
+     * the object that owns it.
+     */
+    triggerPathPrefix: _angular_core.InputSignal<string | null>;
+    /** Raised instead of self-issuing when {@link triggerPathPrefix} is set. */
+    nestedTriggerRequested: _angular_core.OutputEmitterRef<NestedTriggerRequest>;
+    /** Blur counterpart, flushing a trigger the host only marked pending. */
+    nestedTriggerBlurred: _angular_core.OutputEmitterRef<string>;
     /**
      * What the last refresh changed about each attribute's presentation, keyed by attribute name.
      *
@@ -83,8 +106,17 @@ declare class SparkPoFormComponent {
      * `entityType` identity and `SparkService` caches nothing, so re-setting it would re-issue every
      * reference query and lookup fetch on every refresh; mutating it in place would not re-render at
      * all.
+     *
+     * ⚠️ A `model`, not a plain signal, because the page that owns the save has to see it. This form
+     * renders from the overlaid attribute list; `spark-po-edit` and `spark-po-create` build the
+     * payload from their own copy of the same filter. While the overlay stopped here, those two
+     * filtered on the attribute's state *as loaded* — so an attribute a refresh hook revealed was
+     * rendered, filled in by the user, and then silently left out of the save. When the same hook also
+     * made it required (the ordinary case — a field appears *because* it is now needed) the server
+     * refused the save for the very field the user had just filled, and the form became a dead end
+     * with no way forward from inside it.
      */
-    refreshOverlay: _angular_core.WritableSignal<RefreshOverlay>;
+    refreshOverlay: _angular_core.ModelSignal<RefreshOverlay>;
     isRefreshing: _angular_core.WritableSignal<boolean>;
     colors: typeof Color;
     referenceOptions: _angular_core.WritableSignal<Record<string, QueryResultItem[]>>;
@@ -167,9 +199,8 @@ declare class SparkPoFormComponent {
     /**
      * The single funnel every scalar / boolean / inline-cell edit passes through.
      *
-     * `attr` is optional only so the AsDetail modal's recursive form, which has no trigger context,
-     * can still call it. A caller that knows which attribute changed should always say so — without it
-     * no refresh can fire.
+     * `attr` is optional because some editors have nothing useful to say about which attribute moved.
+     * A caller that knows should always say so — without it no refresh can fire.
      */
     onFieldChange(attr?: EntityAttributeDefinition): void;
     /**
@@ -178,8 +209,27 @@ declare class SparkPoFormComponent {
      * addressing scheme being invented for it.
      */
     onInlineCellChange(attr: EntityAttributeDefinition, rowIndex: number, col: EntityAttributeDefinition): void;
-    /** Which detail row the in-flight refresh belongs to, if any. */
+    /**
+     * Which embedded target the in-flight refresh belongs to, if any.
+     *
+     * ⚠️ Tagged, not a nullable `rowIndex`. The two arms write to different places — a row inside
+     * `formData`, versus the modal's working copy in `asDetailFormData` — and an index that happens
+     * to be absent is not the same statement as "this attribute holds one object". With a nullable
+     * index, a row refresh carrying a bad index would fall silently into the object arm.
+     */
     private pendingNestedTrigger;
+    /**
+     * A trigger inside a single embedded AsDetail object, raised by the modal's recursive form.
+     *
+     * The child form does not issue the request itself, for two reasons that both bite. Its
+     * `entityType` is the embedded type, so a payload built there describes `GateSettings` while the
+     * request must describe the Repository that owns it. And nested AsDetail types carry no rights of
+     * their own — the server authorizes a nested refresh on the OWNING type — so a child-issued
+     * request would be asking the wrong question of security.json.
+     */
+    onEmbeddedTrigger(attributeName: string, event: NestedTriggerRequest): void;
+    /** Blur counterpart of {@link onEmbeddedTrigger}, for the child's free-text editors. */
+    onEmbeddedTriggerBlur(path: string): void;
     /**
      * Applies a refresh that ran against a detail row: the row's own values, and the column metadata
      * for the grid it lives in.
@@ -195,6 +245,8 @@ declare class SparkPoFormComponent {
     /** Blur handler for free-text editors — sends the refresh their keystrokes only marked pending. */
     onFieldBlur(attr: EntityAttributeDefinition): void;
     private noteChange;
+    /** `Gate.ProjectMode` — the index-free counterpart of the inline grid's `Jobs[1].Kind`. */
+    private nestedTriggerPath;
     private canRefresh;
     /**
      * Per-instance, never a service: the retry-action modal renders its own `spark-po-form`, and a
@@ -203,6 +255,16 @@ declare class SparkPoFormComponent {
      */
     protected readonly refreshCoordinator: RefreshCoordinator;
     private buildRefreshPayload;
+    /**
+     * The values to post, with the open modal's working copy substituted for the attribute it edits.
+     *
+     * ⚠️ Without this the server receives the embedded object as it was when the modal opened — `{}`
+     * for a gate that has never been set — and the hook decides against values the user cannot see it
+     * ignoring. `formData` deliberately does not hold the in-progress edit (cancelling the modal has
+     * to discard it), so the refresh has to reach into `asDetailFormData` instead. Only the attribute
+     * under edit is substituted; everything else is the form's own state.
+     */
+    private embeddedValues;
     /**
      * Folds replaced option lists into the signals the editors already read, so a refreshed dropdown
      * renders through the same path as a loaded one.
@@ -269,7 +331,7 @@ declare class SparkPoFormComponent {
     removeArrayItem(attr: EntityAttributeDefinition, index: number): Promise<void>;
     onAsDetailReorder(attr: EntityAttributeDefinition, event: CdkDragDrop<Record<string, any>[]>): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<SparkPoFormComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SparkPoFormComponent, "spark-po-form", never, { "entityType": { "alias": "entityType"; "required": false; "isSignal": true; }; "formData": { "alias": "formData"; "required": false; "isSignal": true; }; "validationErrors": { "alias": "validationErrors"; "required": false; "isSignal": true; }; "showButtons": { "alias": "showButtons"; "required": false; "isSignal": true; }; "isSaving": { "alias": "isSaving"; "required": false; "isSignal": true; }; "parentId": { "alias": "parentId"; "required": false; "isSignal": true; }; "parentType": { "alias": "parentType"; "required": false; "isSignal": true; }; "objectTypeId": { "alias": "objectTypeId"; "required": false; "isSignal": true; }; "objectId": { "alias": "objectId"; "required": false; "isSignal": true; }; }, { "formData": "formDataChange"; "save": "save"; "cancel": "cancel"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SparkPoFormComponent, "spark-po-form", never, { "entityType": { "alias": "entityType"; "required": false; "isSignal": true; }; "formData": { "alias": "formData"; "required": false; "isSignal": true; }; "validationErrors": { "alias": "validationErrors"; "required": false; "isSignal": true; }; "showButtons": { "alias": "showButtons"; "required": false; "isSignal": true; }; "isSaving": { "alias": "isSaving"; "required": false; "isSignal": true; }; "parentId": { "alias": "parentId"; "required": false; "isSignal": true; }; "parentType": { "alias": "parentType"; "required": false; "isSignal": true; }; "objectTypeId": { "alias": "objectTypeId"; "required": false; "isSignal": true; }; "objectId": { "alias": "objectId"; "required": false; "isSignal": true; }; "triggerPathPrefix": { "alias": "triggerPathPrefix"; "required": false; "isSignal": true; }; "refreshOverlay": { "alias": "refreshOverlay"; "required": false; "isSignal": true; }; }, { "formData": "formDataChange"; "save": "save"; "cancel": "cancel"; "nestedTriggerRequested": "nestedTriggerRequested"; "nestedTriggerBlurred": "nestedTriggerBlurred"; "refreshOverlay": "refreshOverlayChange"; }, never, never, true, never>;
 }
 
 /**
@@ -348,3 +410,4 @@ declare class SparkLookupPickerComponent {
 }
 
 export { SparkLookupPickerComponent, SparkPoFormComponent, SparkReferencePickerComponent };
+export type { NestedTriggerRequest };

package/types/mintplayer-ng-spark-services.d.ts

@@ -3,6 +3,7 @@ import { RetryActionPayload, RetryActionResult, TranslatedString, StreamingMessa
 import { Observable } from 'rxjs';
 import { SortColumn } from '@mintplayer/pagination';
 import { SafeHtml } from '@angular/platform-browser';
+import { HttpInterceptorFn, HttpFeature, HttpFeatureKind } from '@angular/common/http';
 
 declare class RetryActionService {
     private resolveRetry;
@@ -72,6 +73,13 @@ declare class SparkService {
     private readonly baseUrl;
     private readonly http;
     private readonly retryActionService;
+    /**
+     * How many prompts one request will answer before giving up. Matches the .NET client's
+     * `SparkClient.MaxRetryDepth`, and for the same reason: this is a termination bound, not a
+     * capacity one. Far above any real conversation (Fleet's longest is two) and far below anything
+     * that could hide a spin.
+     */
+    private static readonly MAX_RETRY_DEPTH;
     private readonly dispatcher;
     getEntityTypes(): Promise<EntityType[]>;
     getEntityType(id: string): Promise<EntityType>;
@@ -146,8 +154,9 @@ declare class SparkService {
      * it is editing, and the removal is persisted with the parent. A hook that refuses rejects with a
      * 400 whose `error.error.result.errors` carries the readable reason, exactly like a save.
      *
-     * A POST, because the framework's real delete route is a catch-all that would swallow a sibling
-     * DELETE — see `DeleteRow.cs`.
+     * A POST — as everything is now. It used to be worth explaining: the framework's real delete route
+     * was a catch-all that would have swallowed a sibling DELETE. The catch-all is gone with the rest
+     * of the route variables.
      */
     deleteRow(type: string, options: DeleteRowOptions): Promise<void>;
     delete(type: string, id: string): Promise<void>;
@@ -172,8 +181,16 @@ declare class SparkService {
     updateLookupReferenceValue(name: string, key: string, value: LookupReferenceValue): Promise<LookupReferenceValue>;
     deleteLookupReferenceValue(name: string, key: string): Promise<void>;
     private postWithEnvelope;
-    private putWithEnvelope;
-    private deleteWithEnvelope;
+    /**
+     * A read: posts the request, and returns the response **as-is** rather than unwrapping an
+     * envelope.
+     *
+     * The read endpoints moved from GET to POST so their hooks could prompt, but their success
+     * responses are still bare — a `PersistentObject`, a `QueryResult`. Only the 449 is enveloped,
+     * because a retry has nowhere else to live. So this shares the retry loop with the mutating calls
+     * and nothing else.
+     */
+    private sendRead;
     private sendWithEnvelope;
     private handleEnvelopeRetryError;
     static ɵfac: i0.ɵɵFactoryDeclaration<SparkService, never>;
@@ -271,5 +288,35 @@ declare class SparkQueryActionsService {
     static ɵprov: i0.ɵɵInjectableDeclaration<SparkQueryActionsService>;
 }
 
-export { RetryActionService, SparkIconRegistry, SparkLanguageService, SparkQueryActionsService, SparkService, SparkStreamingService };
+/**
+ * The header carrying the viewer's IANA timezone id, e.g. `Europe/Brussels`.
+ * Must stay in lockstep with `RequestTimeZoneResolver.HeaderName` on the server.
+ */
+declare const SPARK_TIMEZONE_HEADER = "X-Spark-Timezone";
+/**
+ * Returns the browser's IANA zone id, or `null` when the environment cannot name one.
+ *
+ * An id is deliberately sent rather than a numeric offset: an offset is only valid at one instant,
+ * so a server asked to render "next Tuesday at 09:00" from an offset captured today gets it wrong
+ * across a DST boundary. A zone id carries the rules, not one sample of them.
+ */
+declare function resolveBrowserTimeZone(): string | null;
+/**
+ * Attaches {@link SPARK_TIMEZONE_HEADER} to same-origin requests.
+ *
+ * **This does not participate in reading or writing timestamps.** A `DateTimeOffset` means an
+ * instant, and the browser converts in both directions on those paths. The header exists for work
+ * the server starts on its own — a scheduled export, a notification email — where there is no
+ * browser in the loop to do the converting but the output still has to read as local time.
+ */
+declare const sparkTimezoneInterceptor: HttpInterceptorFn;
+/**
+ * `provideHttpClient(...withSparkTimezone())` — registers {@link sparkTimezoneInterceptor}.
+ *
+ * Spreadable alongside `withSparkAuth()`:
+ * `provideHttpClient(...withSparkAuth(), ...withSparkTimezone())`.
+ */
+declare function withSparkTimezone(): HttpFeature<HttpFeatureKind>[];
+
+export { RetryActionService, SPARK_TIMEZONE_HEADER, SparkIconRegistry, SparkLanguageService, SparkQueryActionsService, SparkService, SparkStreamingService, resolveBrowserTimeZone, sparkTimezoneInterceptor, withSparkTimezone };
 export type { DeleteRowOptions, NewObjectOptions };