@wildo-ai/saas-backend-lib 1.1.2 → 1.1.4

package/dist/esm/monitoring/analytics/services/value-moment-engine.backend.service.js

@@ -1,3 +1,35 @@
+/**
+ * Value Moment Engine — evaluates value-moment signals and records what a scope has achieved.
+ *
+ * ## What this was until 2026-09-08 (#414)
+ *
+ * Placeholders. `evaluateOperationSignal` logged, `markAchieved` logged, `getAchievedMoments`
+ * returned an empty array unconditionally, and the handler registry beside it had no registration
+ * path and was never invoked. Meanwhile `analytics.persistence.backendSync` and `backendEvaluation`
+ * both default to TRUE, so an application was promised cross-device persistence and authoritative
+ * evaluation, received neither, and was answered 200.
+ *
+ * ## Where the state lives, and why not in a resource of its own
+ *
+ * `valueMomentsAchieved` on the PROGRESSION STATE row — the same per-scope row milestones use. That
+ * row already carries the `PersonalDataCategory.USAGE` classification, the `RedactionType.RESET`
+ * erasure treatment, the subject-export provenance and the `onParentCreate`/`onParentDelete`
+ * lifecycle that a per-user behavioural record owes. A second resource would have re-declared all of
+ * them for the same shape of data.
+ *
+ * ## Concurrency
+ *
+ * Every write is a compare-and-swap through `atomicGuardedMutation`, guarded on the moment NOT being
+ * achieved. Two operations in the same instant can both observe "not yet achieved"; without the
+ * guard both would write, both would invoke the handler, and a TTFV would be recorded twice with
+ * different timestamps. This is the same guard the milestone evaluator uses, for the same reason.
+ *
+ * ## What ANTI_PATTERN does differently
+ *
+ * `ValueMomentRole.ANTI_PATTERN` is declared as NOT persisted: it re-fires on a cooldown rather than
+ * being achieved once. So it writes nothing here and its cooldown is in-process — in a multi-instance
+ * deployment each instance keeps its own, which is what "not persisted" means rather than a defect.
+ */
 var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -10,53 +42,413 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
+import 'reflect-metadata';
 import { injectable, inject } from 'inversify';
-import { ValueMomentScope } from '@wildo-ai/saas-models';
+import { ProgressionScope, ValueMomentMode, ValueMomentRole, ValueMomentScope, ValueSignalType, } from '@wildo-ai/saas-models';
+import { describeCaughtError } from '../../../errors/utils/error-log-level-classification.backend.utils.js';
 import { SAAS_SERVICE_TYPES } from '../../../inject/models/service-types.js';
-import { LoggerService } from '../../../monitoring/logger/services/logger.service.js';
 import { ValueMomentHandlerRegistryBackendService } from './value-moment-handler-registry.backend.service.js';
+import { valueSignalKey } from './value-moment-definition-registry.backend.service.js';
+/** Default cooldown between re-firings of an ANTI_PATTERN moment. */
+const DEFAULT_ANTI_PATTERN_COOLDOWN_MS = 300_000;
+/**
+ * The outcome of a write, so a caller can answer honestly.
+ *
+ * The controller answered 200 for a discarded write because the engine returned `void` and there was
+ * nothing to report. Every write path now says which of the four things happened.
+ */
+export var ValueMomentWriteOutcome;
+(function (ValueMomentWriteOutcome) {
+    /** Newly achieved and persisted. */
+    ValueMomentWriteOutcome["RECORDED"] = "recorded";
+    /** Already achieved — the compare-and-swap declined, which is success, not failure. */
+    ValueMomentWriteOutcome["ALREADY_ACHIEVED"] = "already_achieved";
+    /** The scope this moment measures is not present on the execution (no user, or no organization). */
+    ValueMomentWriteOutcome["SCOPE_UNAVAILABLE"] = "scope_unavailable";
+    /** The store could not be reached. The caller must NOT report success. */
+    ValueMomentWriteOutcome["NOT_PERSISTED"] = "not_persisted";
+})(ValueMomentWriteOutcome || (ValueMomentWriteOutcome = {}));
+/** Map the analytics scope vocabulary onto the progression-state one. */
+function progressionScopeFor(scope) {
+    return scope === ValueMomentScope.ORGANIZATION ? ProgressionScope.ORGANIZATION : ProgressionScope.USER;
+}
 let ValueMomentEngineBackendService = class ValueMomentEngineBackendService {
     logger;
     handlerRegistry;
-    constructor(logger, handlerRegistry) {
+    definitionRegistry;
+    progressionStateStore;
+    repositoriesRegistry;
+    /**
+     * Last fire time per `<scope>:<scopeId>:<momentIdentifier>` for ANTI_PATTERN moments only.
+     *
+     * In-process on purpose — see the class docstring. Bounded by the number of anti-pattern
+     * definitions times active scopes, which is the same population the definitions already bound.
+     */
+    antiPatternLastFiredAt = new Map();
+    logDebug;
+    constructor(logger, handlerRegistry, definitionRegistry, progressionStateStore, repositoriesRegistry) {
         this.logger = logger;
         this.handlerRegistry = handlerRegistry;
+        this.definitionRegistry = definitionRegistry;
+        this.progressionStateStore = progressionStateStore;
+        this.repositoriesRegistry = repositoriesRegistry;
+        this.logger.setDebugTypeLogging('ValueMomentEngine', false);
+        this.logDebug = this.logger.debugByType('ValueMomentEngine');
     }
+    // =====================================================
+    // Evaluation
+    // =====================================================
     /**
-     * Evaluate an operation signal to determine if any value moments should be triggered.
-     * Placeholder — full implementation deferred.
+     * Evaluate an operation against every value moment carrying a matching RESOURCE_OPERATION signal.
+     *
+     * Never throws. Runs fire-and-forget after the operation's response has been decided, so a failure
+     * here must not surface as an error on a request that already succeeded — the same posture the
+     * milestone evaluator takes.
      */
     async evaluateOperationSignal(params) {
-        this.logger.info(`[ValueMomentEngine] evaluateOperationSignal: resource=${params.resourceType}, operation=${params.operationIdentifier}`);
+        try {
+            const candidates = this.definitionRegistry.getMomentsForOperation(params.resourceType, params.operationIdentifier);
+            /*
+             * NO early return on an empty candidate list.
+             *
+             * It had one, and that made every RESOURCE_STATE-only moment permanently unreachable: the two
+             * signal families are indexed differently — operation signals by `<type>:<operation>`, state
+             * signals by TYPE alone — so an operation with no operation-signal match can still change the
+             * population a state signal counts. Returning here skipped the state pass for exactly the
+             * moments that have nothing else to fire them.
+             */
+            this.logDebug('Evaluating value moments for operation', {
+                trigger: `${params.resourceType}:${params.operationIdentifier}`,
+                candidates: candidates.map(moment => moment.identifier),
+            });
+            for (const moment of candidates) {
+                const signal = moment.signals.find(candidate => candidate.signalType === ValueSignalType.RESOURCE_OPERATION
+                    && candidate.resourceType === params.resourceType
+                    && candidate.operation === params.operationIdentifier);
+                if (!signal)
+                    continue;
+                if (!this.operationSignalMatches(signal, params.operationResult)) {
+                    this.logDebug('Operation signal filtered out', { moment: moment.identifier });
+                    continue;
+                }
+                await this.observeSignal(moment, valueSignalKey(signal), params.principal);
+            }
+            await this.evaluateResourceStateSignals(params.resourceType, params.principal);
+        }
+        catch (error) {
+            this.logger.warn('[ValueMomentEngine] Operation signal evaluation failed (non-blocking)', {
+                error: describeCaughtError(error),
+                resourceType: params.resourceType,
+                operationIdentifier: params.operationIdentifier,
+            });
+        }
+    }
+    /**
+     * A RESOURCE_OPERATION signal's optional field filter.
+     *
+     * SHALLOW EQUALITY over primitives, which is exactly what `ValueSignal_FilterSchema` documents
+     * ("no nested objects or arrays"). A filter whose field is absent from the result does NOT match:
+     * the signal asked for a specific state and the evidence does not show it, so treating absence as
+     * a match would fire moments the author narrowed on purpose.
+     */
+    operationSignalMatches(signal, operationResult) {
+        if (signal.signalType !== ValueSignalType.RESOURCE_OPERATION || !signal.filter)
+            return true;
+        if (typeof operationResult !== 'object' || operationResult === null)
+            return false;
+        const result = operationResult;
+        return Object.entries(signal.filter).every(([field, expected]) => result[field] === expected);
     }
     /**
-     * Emit a generic analytics signal for downstream processing.
-     * Placeholder — full implementation deferred.
+     * RESOURCE_STATE signals — "this scope owns at least N rows of this type matching this filter".
+     *
+     * This is the half `analytics.persistence.backendEvaluation` is specifically about: its own
+     * docstring says the backend evaluates RESOURCE_STATE signals AUTHORITATIVELY, while the frontend
+     * "does optimistic cached count queries". Before #414 neither happened on the backend at all.
+     *
+     * Re-counted on any write to the resource type rather than on a specific operation, because a
+     * state signal asks about the CURRENT population: a create, an update that moves a row into the
+     * filter, and a delete that moves one out all change the answer.
+     *
+     * The count runs through the INFRASTRUCTURE door deliberately. It is a system evaluation with no
+     * request principal — the achieving user is not necessarily reading their own rows through an
+     * authorized operation — so it must not borrow request-tier authorization. The scope filter is
+     * applied HERE, by this method, which is what that door requires of its callers.
+     */
+    async evaluateResourceStateSignals(resourceType, principal) {
+        const candidates = this.definitionRegistry.getMomentsForResourceState(resourceType);
+        if (candidates.length === 0)
+            return;
+        for (const moment of candidates) {
+            const signal = moment.signals.find(candidate => candidate.signalType === ValueSignalType.RESOURCE_STATE && candidate.resourceType === resourceType);
+            if (!signal || signal.signalType !== ValueSignalType.RESOURCE_STATE)
+                continue;
+            const scopeOwnerId = moment.scope === ValueMomentScope.ORGANIZATION
+                ? principal.organizationId
+                : principal.userId;
+            if (!scopeOwnerId)
+                continue;
+            try {
+                /*
+                 * The scope filter is the moment's OWN scope, not the execution's: an organization-scoped
+                 * moment counts the organization's rows even when a member triggered the write. Counting
+                 * without it would measure the whole table and fire the moment for every tenant at once.
+                 */
+                const scopeField = moment.scope === ValueMomentScope.ORGANIZATION ? 'organizationId' : 'userId';
+                const count = await this.repositoriesRegistry.countDocumentsForInfrastructure(resourceType, { ...(signal.filter ?? {}), [scopeField]: scopeOwnerId });
+                if (count >= signal.threshold) {
+                    await this.observeSignal(moment, valueSignalKey(signal), principal);
+                }
+            }
+            catch (error) {
+                /*
+                 * A resource with no such scope field, or no repository, cannot be counted — and a moment
+                 * that cannot be measured must not be achieved. Logged rather than thrown: this runs
+                 * fire-and-forget after a request that already succeeded.
+                 */
+                this.logger.warn('[ValueMomentEngine] RESOURCE_STATE signal could not be counted', {
+                    moment: moment.identifier,
+                    resourceType,
+                    error: describeCaughtError(error),
+                });
+            }
+        }
+    }
+    /**
+     * A generic analytics signal — the CUSTOM_EVENT half of the vocabulary.
+     *
+     * `context` names the scope this event belongs to, because a custom event is emitted by code that
+     * knows whose journey it is measuring and the engine cannot recover that from the event name.
      */
     async emitSignal(signal, context) {
-        this.logger.info(`[ValueMomentEngine] emitSignal: type=${signal.signalType}, event=${signal.eventName}, scope=${context.scope}, entityId=${context.entityId}`);
+        try {
+            const candidates = this.definitionRegistry.getMomentsForEvent(signal.eventName);
+            if (candidates.length === 0)
+                return;
+            const principal = context.scope === ValueMomentScope.ORGANIZATION
+                ? { organizationId: context.entityId }
+                : { userId: context.entityId };
+            for (const moment of candidates) {
+                const matching = moment.signals.find(candidate => candidate.signalType === ValueSignalType.CUSTOM_EVENT && candidate.eventName === signal.eventName);
+                if (!matching)
+                    continue;
+                await this.observeSignal(moment, valueSignalKey(matching), principal);
+            }
+        }
+        catch (error) {
+            this.logger.warn('[ValueMomentEngine] Custom event signal evaluation failed (non-blocking)', {
+                error: describeCaughtError(error),
+                eventName: signal.eventName,
+            });
+        }
+    }
+    // =====================================================
+    // Achievement
+    // =====================================================
+    /**
+     * Record that one of a moment's signals fired, and achieve the moment if that completes it.
+     *
+     * `ANY` completes on any signal; `ALL` completes when every signal key has been observed. The
+     * observation itself is persisted for both, so an `ALL` moment accumulates across requests — which
+     * is the only reason `ALL` can mean anything on a stateless backend.
+     */
+    async observeSignal(moment, signalKey, principal) {
+        if (moment.role === ValueMomentRole.ANTI_PATTERN) {
+            return this.fireAntiPattern(moment, principal);
+        }
+        const target = this.resolveTarget(moment, principal);
+        if (!target)
+            return ValueMomentWriteOutcome.SCOPE_UNAVAILABLE;
+        const state = await this.progressionStateStore.loadOrCreate(target.resourceType, target.scopeId);
+        if (state.valueMomentsAchieved?.[moment.identifier]?.achievedAt) {
+            return ValueMomentWriteOutcome.ALREADY_ACHIEVED;
+        }
+        if (!this.prerequisitesMet(moment, state)) {
+            this.logDebug('Value moment suppressed by requires/beforeStage', { moment: moment.identifier });
+            return ValueMomentWriteOutcome.SCOPE_UNAVAILABLE;
+        }
+        const observed = new Set(state.valueMomentsAchieved?.[moment.identifier]?.signalsObserved ?? []);
+        observed.add(signalKey);
+        const required = moment.mode === ValueMomentMode.ALL
+            ? new Set(moment.signals.map(valueSignalKey))
+            : new Set([signalKey]);
+        const complete = [...required].every(key => observed.has(key));
+        const scopeFilter = this.progressionStateStore.scopeFilter(target.resourceType, target.scopeId);
+        const updated = await this.repositoriesRegistry.atomicGuardedMutation(target.resourceType, {
+            ...scopeFilter,
+            // The compare-and-swap. Two concurrent operations both read "not achieved"; only one wins
+            // this write, so only one invokes the handler and only one timestamp is recorded.
+            [`valueMomentsAchieved.${moment.identifier}.achievedAt`]: { $exists: false },
+        }, {
+            set: {
+                [`valueMomentsAchieved.${moment.identifier}`]: {
+                    signalsObserved: [...observed],
+                    ...(complete ? { achievedAt: new Date() } : {}),
+                },
+            },
+        });
+        if (!updated) {
+            /*
+             * The guard declined. Either a concurrent request achieved it first — success, and the handler
+             * has already run once — or the row could not be written at all. They are distinguishable by
+             * re-reading, and the distinction matters because one is a 200 and the other is not.
+             */
+            const after = await this.progressionStateStore.loadOrCreate(target.resourceType, target.scopeId);
+            return after.valueMomentsAchieved?.[moment.identifier]?.achievedAt
+                ? ValueMomentWriteOutcome.ALREADY_ACHIEVED
+                : ValueMomentWriteOutcome.NOT_PERSISTED;
+        }
+        if (!complete) {
+            this.logDebug('Value moment progressed', {
+                moment: moment.identifier,
+                observed: [...observed],
+                required: [...required],
+            });
+            return ValueMomentWriteOutcome.RECORDED;
+        }
+        await this.invokeAchievementHandler(moment, target.scopeId);
+        return ValueMomentWriteOutcome.RECORDED;
+    }
+    /**
+     * ANTI_PATTERN: fire the handler, persist nothing, respect the cooldown.
+     *
+     * The role's own contract. It measures a recurring frustration rather than a one-time achievement,
+     * so there is no "achieved" state to record and re-firing is the point.
+     */
+    async fireAntiPattern(moment, principal) {
+        const scopeId = moment.scope === ValueMomentScope.ORGANIZATION ? principal.organizationId : principal.userId;
+        if (!scopeId)
+            return ValueMomentWriteOutcome.SCOPE_UNAVAILABLE;
+        const key = `${moment.scope}:${scopeId}:${moment.identifier}`;
+        const cooldown = moment.cooldownMs ?? DEFAULT_ANTI_PATTERN_COOLDOWN_MS;
+        const lastFired = this.antiPatternLastFiredAt.get(key);
+        if (lastFired !== undefined && Date.now() - lastFired < cooldown) {
+            return ValueMomentWriteOutcome.ALREADY_ACHIEVED;
+        }
+        this.antiPatternLastFiredAt.set(key, Date.now());
+        await this.invokeAchievementHandler(moment, scopeId);
+        return ValueMomentWriteOutcome.RECORDED;
+    }
+    /**
+     * `requires` gates a moment until its prerequisites are achieved; `beforeStage` SUPPRESSES it once
+     * any named stage is. Both read the same persisted map, so a moment whose stage was reached in an
+     * earlier request stays suppressed.
+     */
+    prerequisitesMet(moment, state) {
+        const achieved = state.valueMomentsAchieved ?? {};
+        if (moment.requires?.length && !moment.requires.every(required => achieved[required]?.achievedAt)) {
+            return false;
+        }
+        if (moment.beforeStage?.length && moment.beforeStage.some(stage => achieved[stage]?.achievedAt)) {
+            return false;
+        }
+        return true;
+    }
+    resolveTarget(moment, principal) {
+        const { resourceType, scopeId } = this.progressionStateStore.resolveScopeTarget(progressionScopeFor(moment.scope), principal.userId, principal.organizationId);
+        return scopeId ? { resourceType, scopeId } : undefined;
+    }
+    /**
+     * Invoke the moment's registered backend handler, if it declared one.
+     *
+     * Failures are logged and swallowed: the moment IS achieved and the record is already written, so
+     * a handler that throws must not make the achievement look like it did not happen. The registry
+     * warns on its own when a declared handler was never registered.
+     */
+    async invokeAchievementHandler(moment, scopeEntityId) {
+        const handlerRef = moment.onAchieved?.backendHandler;
+        if (!handlerRef)
+            return;
+        try {
+            await this.handlerRegistry.invokeHandler(handlerRef, {
+                momentIdentifier: moment.identifier,
+                role: moment.role,
+                scope: moment.scope,
+                scopeEntityId,
+                achievedAt: Date.now(),
+                executionContext: undefined,
+            });
+        }
+        catch (error) {
+            this.logger.warn('[ValueMomentEngine] onAchieved handler failed', {
+                moment: moment.identifier,
+                handlerRef,
+                error: describeCaughtError(error),
+            });
+        }
     }
+    // =====================================================
+    // Read / explicit write
+    // =====================================================
     /**
-     * Retrieve achieved moments for a given execution context.
-     * Placeholder — returns empty array until persistence is implemented.
+     * The moments this principal has achieved.
+     *
+     * Returns the USER scope's moments, plus the ORGANIZATION scope's when the execution carries one —
+     * both are "what this person has reached", and the frontend's achieved-set is not scope-split.
      */
-    async getAchievedMoments(_executionContext) {
-        return [];
+    async getAchievedMoments(principal) {
+        const results = [];
+        for (const scope of [ProgressionScope.USER, ProgressionScope.ORGANIZATION]) {
+            const { resourceType, scopeId } = this.progressionStateStore.resolveScopeTarget(scope, principal.userId, principal.organizationId);
+            if (!scopeId)
+                continue;
+            const state = await this.progressionStateStore.loadOrCreate(resourceType, scopeId);
+            for (const [identifier, record] of Object.entries(state.valueMomentsAchieved ?? {})) {
+                if (record.achievedAt)
+                    results.push({ momentIdentifier: identifier, achievedAt: record.achievedAt });
+            }
+        }
+        return results;
     }
     /**
-     * Mark a value moment as achieved.
-     * Placeholder — logs and returns until persistence is implemented.
+     * Record a moment as achieved directly — the frontend's `backendSync` path, where the frontend
+     * evaluated a signal the backend cannot see (a view visit, a feature access) and reports it.
+     *
+     * The scope comes from the DEFINITION when the moment is registered, and from the caller only when
+     * it is not: an application may sync a moment the backend does not know about, and refusing it
+     * would lose the frontend's evaluation entirely.
      */
-    async markAchieved(momentIdentifier, _executionContext, scope) {
-        this.logger.info(`[ValueMomentEngine] markAchieved: moment=${momentIdentifier}, scope=${scope ?? ValueMomentScope.USER}`);
+    async markAchieved(momentIdentifier, principal, requestedScope) {
+        const definition = this.definitionRegistry.getDefinition(momentIdentifier);
+        const scope = (definition?.scope ?? requestedScope ?? ValueMomentScope.USER);
+        const { resourceType, scopeId } = this.progressionStateStore.resolveScopeTarget(progressionScopeFor(scope), principal.userId, principal.organizationId);
+        if (!scopeId)
+            return ValueMomentWriteOutcome.SCOPE_UNAVAILABLE;
+        const scopeFilter = this.progressionStateStore.scopeFilter(resourceType, scopeId);
+        await this.progressionStateStore.loadOrCreate(resourceType, scopeId);
+        const updated = await this.repositoriesRegistry.atomicGuardedMutation(resourceType, {
+            ...scopeFilter,
+            [`valueMomentsAchieved.${momentIdentifier}.achievedAt`]: { $exists: false },
+        }, {
+            set: {
+                [`valueMomentsAchieved.${momentIdentifier}`]: {
+                    // Every signal the definition declares, because the frontend reporting an achievement is
+                    // reporting the WHOLE moment rather than one of its signals. An unregistered moment has
+                    // no signals to name, and the empty list is honest about that.
+                    signalsObserved: definition?.signals.map(valueSignalKey) ?? [],
+                    achievedAt: new Date(),
+                },
+            },
+        });
+        if (!updated) {
+            const after = await this.progressionStateStore.loadOrCreate(resourceType, scopeId);
+            return after.valueMomentsAchieved?.[momentIdentifier]?.achievedAt
+                ? ValueMomentWriteOutcome.ALREADY_ACHIEVED
+                : ValueMomentWriteOutcome.NOT_PERSISTED;
+        }
+        if (definition)
+            await this.invokeAchievementHandler(definition, scopeId);
+        return ValueMomentWriteOutcome.RECORDED;
     }
 };
 ValueMomentEngineBackendService = __decorate([
     injectable(),
     __param(0, inject(SAAS_SERVICE_TYPES.Logger)),
     __param(1, inject(SAAS_SERVICE_TYPES.ValueMomentHandlerRegistry)),
-    __metadata("design:paramtypes", [LoggerService,
-        ValueMomentHandlerRegistryBackendService])
+    __param(2, inject(SAAS_SERVICE_TYPES.ValueMomentDefinitionRegistry)),
+    __param(3, inject(SAAS_SERVICE_TYPES.ProgressionStateStore)),
+    __param(4, inject(SAAS_SERVICE_TYPES.RepositoriesRegistryHandlerService)),
+    __metadata("design:paramtypes", [Function, ValueMomentHandlerRegistryBackendService, Function, Function, Function])
 ], ValueMomentEngineBackendService);
 export { ValueMomentEngineBackendService };
 //# sourceMappingURL=value-moment-engine.backend.service.js.map

package/dist/esm/monitoring/analytics/services/value-moment-engine.backend.service.js.map

@@ -1 +1 @@
-{"version":3,"file":"value-moment-engine.backend.service.js","sourceRoot":"","sources":["../../../../../../src/monitoring/analytics/services/value-moment-engine.backend.service.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,gDAAgD,CAAC;AACpF,OAAO,EAAE,aAAa,EAAE,MAAM,8DAA8D,CAAC;AAC7F,OAAO,EAAE,wCAAwC,EAAE,MAAM,iDAAiD,CAAC;AAGpG,IAAM,+BAA+B,GAArC,MAAM,+BAA+B;IAEG;IACoB;IAFjE,YAC6C,MAAqB,EACD,eAAyD;QAD7E,WAAM,GAAN,MAAM,CAAe;QACD,oBAAe,GAAf,eAAe,CAA0C;IACvH,CAAC;IAEJ;;;OAGG;IACH,KAAK,CAAC,uBAAuB,CAAC,MAK7B;QACC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,yDAAyD,MAAM,CAAC,YAAY,eAAe,MAAM,CAAC,mBAAmB,EAAE,CAAC,CAAC;IAC5I,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,UAAU,CACd,MAAiD,EACjD,OAA4C;QAE5C,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,wCAAwC,MAAM,CAAC,UAAU,WAAW,MAAM,CAAC,SAAS,WAAW,OAAO,CAAC,KAAK,cAAc,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC;IACjK,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,kBAAkB,CAAC,iBAA0B;QACjD,OAAO,EAAE,CAAC;IACZ,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,YAAY,CAAC,gBAAwB,EAAE,iBAA0B,EAAE,KAAc;QACrF,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,4CAA4C,gBAAgB,WAAW,KAAK,IAAI,gBAAgB,CAAC,IAAI,EAAE,CAAC,CAAC;IAC5H,CAAC;CACF,CAAA;AA7CY,+BAA+B;IAD3C,UAAU,EAAE;IAGR,WAAA,MAAM,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAA;IACjC,WAAA,MAAM,CAAC,kBAAkB,CAAC,0BAA0B,CAAC,CAAA;qCADH,aAAa;QACgB,wCAAwC;GAH/G,+BAA+B,CA6C3C","sourcesContent":["import { injectable, inject } from 'inversify';\nimport { ValueMomentScope } from '@wildo-ai/saas-models';\nimport { SAAS_SERVICE_TYPES } from '~wildo-backend-lib/inject/models/service-types';\nimport { LoggerService } from '~wildo-backend-lib/monitoring/logger/services/logger.service';\nimport { ValueMomentHandlerRegistryBackendService } from './value-moment-handler-registry.backend.service';\n\n@injectable()\nexport class ValueMomentEngineBackendService {\n  constructor(\n    @inject(SAAS_SERVICE_TYPES.Logger) private logger: LoggerService,\n    @inject(SAAS_SERVICE_TYPES.ValueMomentHandlerRegistry) private handlerRegistry: ValueMomentHandlerRegistryBackendService,\n  ) {}\n\n  /**\n   * Evaluate an operation signal to determine if any value moments should be triggered.\n   * Placeholder — full implementation deferred.\n   */\n  async evaluateOperationSignal(params: {\n    resourceType: string;\n    operationIdentifier: string;\n    operationResult: unknown;\n    executionContext: unknown;\n  }): Promise<void> {\n    this.logger.info(`[ValueMomentEngine] evaluateOperationSignal: resource=${params.resourceType}, operation=${params.operationIdentifier}`);\n  }\n\n  /**\n   * Emit a generic analytics signal for downstream processing.\n   * Placeholder — full implementation deferred.\n   */\n  async emitSignal(\n    signal: { signalType: string; eventName: string },\n    context: { scope: string; entityId: string },\n  ): Promise<void> {\n    this.logger.info(`[ValueMomentEngine] emitSignal: type=${signal.signalType}, event=${signal.eventName}, scope=${context.scope}, entityId=${context.entityId}`);\n  }\n\n  /**\n   * Retrieve achieved moments for a given execution context.\n   * Placeholder — returns empty array until persistence is implemented.\n   */\n  async getAchievedMoments(_executionContext: unknown): Promise<{ momentIdentifier: string }[]> {\n    return [];\n  }\n\n  /**\n   * Mark a value moment as achieved.\n   * Placeholder — logs and returns until persistence is implemented.\n   */\n  async markAchieved(momentIdentifier: string, _executionContext: unknown, scope?: string): Promise<void> {\n    this.logger.info(`[ValueMomentEngine] markAchieved: moment=${momentIdentifier}, scope=${scope ?? ValueMomentScope.USER}`);\n  }\n}\n"]}
+{"version":3,"file":"value-moment-engine.backend.service.js","sourceRoot":"","sources":["../../../../../src/monitoring/analytics/services/value-moment-engine.backend.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Value Moment Engine — evaluates value-moment signals and records what a scope has achieved.\n *\n * ## What this was until 2026-09-08 (#414)\n *\n * Placeholders. `evaluateOperationSignal` logged, `markAchieved` logged, `getAchievedMoments`\n * returned an empty array unconditionally, and the handler registry beside it had no registration\n * path and was never invoked. Meanwhile `analytics.persistence.backendSync` and `backendEvaluation`\n * both default to TRUE, so an application was promised cross-device persistence and authoritative\n * evaluation, received neither, and was answered 200.\n *\n * ## Where the state lives, and why not in a resource of its own\n *\n * `valueMomentsAchieved` on the PROGRESSION STATE row — the same per-scope row milestones use. That\n * row already carries the `PersonalDataCategory.USAGE` classification, the `RedactionType.RESET`\n * erasure treatment, the subject-export provenance and the `onParentCreate`/`onParentDelete`\n * lifecycle that a per-user behavioural record owes. A second resource would have re-declared all of\n * them for the same shape of data.\n *\n * ## Concurrency\n *\n * Every write is a compare-and-swap through `atomicGuardedMutation`, guarded on the moment NOT being\n * achieved. Two operations in the same instant can both observe \"not yet achieved\"; without the\n * guard both would write, both would invoke the handler, and a TTFV would be recorded twice with\n * different timestamps. This is the same guard the milestone evaluator uses, for the same reason.\n *\n * ## What ANTI_PATTERN does differently\n *\n * `ValueMomentRole.ANTI_PATTERN` is declared as NOT persisted: it re-fires on a cooldown rather than\n * being achieved once. So it writes nothing here and its cooldown is in-process — in a multi-instance\n * deployment each instance keeps its own, which is what \"not persisted\" means rather than a defect.\n */\n\nimport 'reflect-metadata';\nimport { injectable, inject } from 'inversify';\nimport {\n  ProgressionScope,\n  ValueMomentMode,\n  ValueMomentRole,\n  ValueMomentScope,\n  ValueSignalType,\n} from '@wildo-ai/saas-models';\nimport type { ProgressionState, ValueMoment, ValueSignal } from '@wildo-ai/saas-models';\n\nimport { describeCaughtError } from '~wildo-backend-lib/errors/utils/error-log-level-classification.backend.utils';\nimport { SAAS_SERVICE_TYPES } from '~wildo-backend-lib/inject/models/service-types';\nimport type { LoggerService } from '~wildo-backend-lib/monitoring/logger/services/logger.service';\nimport type { RepositoriesRegistryHandlerBackendService } from '~wildo-backend-lib/base-classes/services/repositories/repositories-registry-handler.backend.service';\nimport type { ProgressionStateStoreBackendService } from '~wildo-backend-lib/guidance/services/progression-state-store.backend.service';\nimport { ValueMomentHandlerRegistryBackendService } from './value-moment-handler-registry.backend.service';\nimport { valueSignalKey } from './value-moment-definition-registry.backend.service';\nimport type { ValueMomentDefinitionRegistryBackendService } from './value-moment-definition-registry.backend.service';\n\n/** Default cooldown between re-firings of an ANTI_PATTERN moment. */\nconst DEFAULT_ANTI_PATTERN_COOLDOWN_MS = 300_000;\n\n/** The identity a signal is evaluated against — either id may be absent. */\nexport interface ValueMomentPrincipal {\n  userId?: string;\n  organizationId?: string;\n}\n\n/**\n * The outcome of a write, so a caller can answer honestly.\n *\n * The controller answered 200 for a discarded write because the engine returned `void` and there was\n * nothing to report. Every write path now says which of the four things happened.\n */\nexport enum ValueMomentWriteOutcome {\n  /** Newly achieved and persisted. */\n  RECORDED = 'recorded',\n  /** Already achieved — the compare-and-swap declined, which is success, not failure. */\n  ALREADY_ACHIEVED = 'already_achieved',\n  /** The scope this moment measures is not present on the execution (no user, or no organization). */\n  SCOPE_UNAVAILABLE = 'scope_unavailable',\n  /** The store could not be reached. The caller must NOT report success. */\n  NOT_PERSISTED = 'not_persisted',\n}\n\n/** Map the analytics scope vocabulary onto the progression-state one. */\nfunction progressionScopeFor(scope: ValueMomentScope): ProgressionScope {\n  return scope === ValueMomentScope.ORGANIZATION ? ProgressionScope.ORGANIZATION : ProgressionScope.USER;\n}\n\n@injectable()\nexport class ValueMomentEngineBackendService {\n  /**\n   * Last fire time per `<scope>:<scopeId>:<momentIdentifier>` for ANTI_PATTERN moments only.\n   *\n   * In-process on purpose — see the class docstring. Bounded by the number of anti-pattern\n   * definitions times active scopes, which is the same population the definitions already bound.\n   */\n  private readonly antiPatternLastFiredAt = new Map<string, number>();\n\n  private logDebug: (message: string, context?: Record<string, unknown>) => void;\n\n  constructor(\n    @inject(SAAS_SERVICE_TYPES.Logger) private logger: LoggerService,\n    @inject(SAAS_SERVICE_TYPES.ValueMomentHandlerRegistry) private handlerRegistry: ValueMomentHandlerRegistryBackendService,\n    @inject(SAAS_SERVICE_TYPES.ValueMomentDefinitionRegistry) private definitionRegistry: ValueMomentDefinitionRegistryBackendService,\n    @inject(SAAS_SERVICE_TYPES.ProgressionStateStore) private progressionStateStore: ProgressionStateStoreBackendService,\n    @inject(SAAS_SERVICE_TYPES.RepositoriesRegistryHandlerService) private repositoriesRegistry: RepositoriesRegistryHandlerBackendService,\n  ) {\n    this.logger.setDebugTypeLogging('ValueMomentEngine', false);\n    this.logDebug = this.logger.debugByType('ValueMomentEngine');\n  }\n\n  // =====================================================\n  // Evaluation\n  // =====================================================\n\n  /**\n   * Evaluate an operation against every value moment carrying a matching RESOURCE_OPERATION signal.\n   *\n   * Never throws. Runs fire-and-forget after the operation's response has been decided, so a failure\n   * here must not surface as an error on a request that already succeeded — the same posture the\n   * milestone evaluator takes.\n   */\n  public async evaluateOperationSignal(params: {\n    resourceType: string;\n    operationIdentifier: string;\n    operationResult: unknown;\n    principal: ValueMomentPrincipal;\n  }): Promise<void> {\n    try {\n      const candidates = this.definitionRegistry.getMomentsForOperation(params.resourceType, params.operationIdentifier);\n\n      /*\n       * NO early return on an empty candidate list.\n       *\n       * It had one, and that made every RESOURCE_STATE-only moment permanently unreachable: the two\n       * signal families are indexed differently — operation signals by `<type>:<operation>`, state\n       * signals by TYPE alone — so an operation with no operation-signal match can still change the\n       * population a state signal counts. Returning here skipped the state pass for exactly the\n       * moments that have nothing else to fire them.\n       */\n      this.logDebug('Evaluating value moments for operation', {\n        trigger: `${params.resourceType}:${params.operationIdentifier}`,\n        candidates: candidates.map(moment => moment.identifier),\n      });\n\n      for (const moment of candidates) {\n        const signal = moment.signals.find(candidate =>\n          candidate.signalType === ValueSignalType.RESOURCE_OPERATION\n          && candidate.resourceType === params.resourceType\n          && candidate.operation === params.operationIdentifier);\n        if (!signal) continue;\n\n        if (!this.operationSignalMatches(signal, params.operationResult)) {\n          this.logDebug('Operation signal filtered out', { moment: moment.identifier });\n          continue;\n        }\n\n        await this.observeSignal(moment, valueSignalKey(signal), params.principal);\n      }\n\n      await this.evaluateResourceStateSignals(params.resourceType, params.principal);\n    } catch (error) {\n      this.logger.warn('[ValueMomentEngine] Operation signal evaluation failed (non-blocking)', {\n        error: describeCaughtError(error),\n        resourceType: params.resourceType,\n        operationIdentifier: params.operationIdentifier,\n      });\n    }\n  }\n\n  /**\n   * A RESOURCE_OPERATION signal's optional field filter.\n   *\n   * SHALLOW EQUALITY over primitives, which is exactly what `ValueSignal_FilterSchema` documents\n   * (\"no nested objects or arrays\"). A filter whose field is absent from the result does NOT match:\n   * the signal asked for a specific state and the evidence does not show it, so treating absence as\n   * a match would fire moments the author narrowed on purpose.\n   */\n  private operationSignalMatches(signal: ValueSignal, operationResult: unknown): boolean {\n    if (signal.signalType !== ValueSignalType.RESOURCE_OPERATION || !signal.filter) return true;\n    if (typeof operationResult !== 'object' || operationResult === null) return false;\n    const result = operationResult as Record<string, unknown>;\n    return Object.entries(signal.filter).every(([field, expected]) => result[field] === expected);\n  }\n\n  /**\n   * RESOURCE_STATE signals — \"this scope owns at least N rows of this type matching this filter\".\n   *\n   * This is the half `analytics.persistence.backendEvaluation` is specifically about: its own\n   * docstring says the backend evaluates RESOURCE_STATE signals AUTHORITATIVELY, while the frontend\n   * \"does optimistic cached count queries\". Before #414 neither happened on the backend at all.\n   *\n   * Re-counted on any write to the resource type rather than on a specific operation, because a\n   * state signal asks about the CURRENT population: a create, an update that moves a row into the\n   * filter, and a delete that moves one out all change the answer.\n   *\n   * The count runs through the INFRASTRUCTURE door deliberately. It is a system evaluation with no\n   * request principal — the achieving user is not necessarily reading their own rows through an\n   * authorized operation — so it must not borrow request-tier authorization. The scope filter is\n   * applied HERE, by this method, which is what that door requires of its callers.\n   */\n  private async evaluateResourceStateSignals(resourceType: string, principal: ValueMomentPrincipal): Promise<void> {\n    const candidates = this.definitionRegistry.getMomentsForResourceState(resourceType);\n    if (candidates.length === 0) return;\n\n    for (const moment of candidates) {\n      const signal = moment.signals.find(candidate =>\n        candidate.signalType === ValueSignalType.RESOURCE_STATE && candidate.resourceType === resourceType);\n      if (!signal || signal.signalType !== ValueSignalType.RESOURCE_STATE) continue;\n\n      const scopeOwnerId = moment.scope === ValueMomentScope.ORGANIZATION\n        ? principal.organizationId\n        : principal.userId;\n      if (!scopeOwnerId) continue;\n\n      try {\n        /*\n         * The scope filter is the moment's OWN scope, not the execution's: an organization-scoped\n         * moment counts the organization's rows even when a member triggered the write. Counting\n         * without it would measure the whole table and fire the moment for every tenant at once.\n         */\n        const scopeField = moment.scope === ValueMomentScope.ORGANIZATION ? 'organizationId' : 'userId';\n        const count = await this.repositoriesRegistry.countDocumentsForInfrastructure(\n          resourceType as never,\n          { ...(signal.filter ?? {}), [scopeField]: scopeOwnerId },\n        );\n\n        if (count >= signal.threshold) {\n          await this.observeSignal(moment, valueSignalKey(signal), principal);\n        }\n      } catch (error) {\n        /*\n         * A resource with no such scope field, or no repository, cannot be counted — and a moment\n         * that cannot be measured must not be achieved. Logged rather than thrown: this runs\n         * fire-and-forget after a request that already succeeded.\n         */\n        this.logger.warn('[ValueMomentEngine] RESOURCE_STATE signal could not be counted', {\n          moment: moment.identifier,\n          resourceType,\n          error: describeCaughtError(error),\n        });\n      }\n    }\n  }\n\n  /**\n   * A generic analytics signal — the CUSTOM_EVENT half of the vocabulary.\n   *\n   * `context` names the scope this event belongs to, because a custom event is emitted by code that\n   * knows whose journey it is measuring and the engine cannot recover that from the event name.\n   */\n  public async emitSignal(\n    signal: { signalType: string; eventName: string },\n    context: { scope: string; entityId: string },\n  ): Promise<void> {\n    try {\n      const candidates = this.definitionRegistry.getMomentsForEvent(signal.eventName);\n      if (candidates.length === 0) return;\n\n      const principal: ValueMomentPrincipal = context.scope === ValueMomentScope.ORGANIZATION\n        ? { organizationId: context.entityId }\n        : { userId: context.entityId };\n\n      for (const moment of candidates) {\n        const matching = moment.signals.find(candidate =>\n          candidate.signalType === ValueSignalType.CUSTOM_EVENT && candidate.eventName === signal.eventName);\n        if (!matching) continue;\n        await this.observeSignal(moment, valueSignalKey(matching), principal);\n      }\n    } catch (error) {\n      this.logger.warn('[ValueMomentEngine] Custom event signal evaluation failed (non-blocking)', {\n        error: describeCaughtError(error),\n        eventName: signal.eventName,\n      });\n    }\n  }\n\n  // =====================================================\n  // Achievement\n  // =====================================================\n\n  /**\n   * Record that one of a moment's signals fired, and achieve the moment if that completes it.\n   *\n   * `ANY` completes on any signal; `ALL` completes when every signal key has been observed. The\n   * observation itself is persisted for both, so an `ALL` moment accumulates across requests — which\n   * is the only reason `ALL` can mean anything on a stateless backend.\n   */\n  private async observeSignal(moment: ValueMoment, signalKey: string, principal: ValueMomentPrincipal): Promise<ValueMomentWriteOutcome> {\n    if (moment.role === ValueMomentRole.ANTI_PATTERN) {\n      return this.fireAntiPattern(moment, principal);\n    }\n\n    const target = this.resolveTarget(moment, principal);\n    if (!target) return ValueMomentWriteOutcome.SCOPE_UNAVAILABLE;\n\n    const state = await this.progressionStateStore.loadOrCreate(target.resourceType, target.scopeId);\n\n    if (state.valueMomentsAchieved?.[moment.identifier]?.achievedAt) {\n      return ValueMomentWriteOutcome.ALREADY_ACHIEVED;\n    }\n    if (!this.prerequisitesMet(moment, state)) {\n      this.logDebug('Value moment suppressed by requires/beforeStage', { moment: moment.identifier });\n      return ValueMomentWriteOutcome.SCOPE_UNAVAILABLE;\n    }\n\n    const observed = new Set(state.valueMomentsAchieved?.[moment.identifier]?.signalsObserved ?? []);\n    observed.add(signalKey);\n\n    const required = moment.mode === ValueMomentMode.ALL\n      ? new Set(moment.signals.map(valueSignalKey))\n      : new Set([signalKey]);\n    const complete = [...required].every(key => observed.has(key));\n\n    const scopeFilter = this.progressionStateStore.scopeFilter(target.resourceType, target.scopeId);\n    const updated = await this.repositoriesRegistry.atomicGuardedMutation<ProgressionState>(\n      target.resourceType,\n      {\n        ...scopeFilter,\n        // The compare-and-swap. Two concurrent operations both read \"not achieved\"; only one wins\n        // this write, so only one invokes the handler and only one timestamp is recorded.\n        [`valueMomentsAchieved.${moment.identifier}.achievedAt`]: { $exists: false },\n      },\n      {\n        set: {\n          [`valueMomentsAchieved.${moment.identifier}`]: {\n            signalsObserved: [...observed],\n            ...(complete ? { achievedAt: new Date() } : {}),\n          },\n        },\n      },\n    );\n\n    if (!updated) {\n      /*\n       * The guard declined. Either a concurrent request achieved it first — success, and the handler\n       * has already run once — or the row could not be written at all. They are distinguishable by\n       * re-reading, and the distinction matters because one is a 200 and the other is not.\n       */\n      const after = await this.progressionStateStore.loadOrCreate(target.resourceType, target.scopeId);\n      return after.valueMomentsAchieved?.[moment.identifier]?.achievedAt\n        ? ValueMomentWriteOutcome.ALREADY_ACHIEVED\n        : ValueMomentWriteOutcome.NOT_PERSISTED;\n    }\n\n    if (!complete) {\n      this.logDebug('Value moment progressed', {\n        moment: moment.identifier,\n        observed: [...observed],\n        required: [...required],\n      });\n      return ValueMomentWriteOutcome.RECORDED;\n    }\n\n    await this.invokeAchievementHandler(moment, target.scopeId);\n    return ValueMomentWriteOutcome.RECORDED;\n  }\n\n  /**\n   * ANTI_PATTERN: fire the handler, persist nothing, respect the cooldown.\n   *\n   * The role's own contract. It measures a recurring frustration rather than a one-time achievement,\n   * so there is no \"achieved\" state to record and re-firing is the point.\n   */\n  private async fireAntiPattern(moment: ValueMoment, principal: ValueMomentPrincipal): Promise<ValueMomentWriteOutcome> {\n    const scopeId = moment.scope === ValueMomentScope.ORGANIZATION ? principal.organizationId : principal.userId;\n    if (!scopeId) return ValueMomentWriteOutcome.SCOPE_UNAVAILABLE;\n\n    const key = `${moment.scope}:${scopeId}:${moment.identifier}`;\n    const cooldown = moment.cooldownMs ?? DEFAULT_ANTI_PATTERN_COOLDOWN_MS;\n    const lastFired = this.antiPatternLastFiredAt.get(key);\n    if (lastFired !== undefined && Date.now() - lastFired < cooldown) {\n      return ValueMomentWriteOutcome.ALREADY_ACHIEVED;\n    }\n\n    this.antiPatternLastFiredAt.set(key, Date.now());\n    await this.invokeAchievementHandler(moment, scopeId);\n    return ValueMomentWriteOutcome.RECORDED;\n  }\n\n  /**\n   * `requires` gates a moment until its prerequisites are achieved; `beforeStage` SUPPRESSES it once\n   * any named stage is. Both read the same persisted map, so a moment whose stage was reached in an\n   * earlier request stays suppressed.\n   */\n  private prerequisitesMet(moment: ValueMoment, state: ProgressionState): boolean {\n    const achieved = state.valueMomentsAchieved ?? {};\n    if (moment.requires?.length && !moment.requires.every(required => achieved[required]?.achievedAt)) {\n      return false;\n    }\n    if (moment.beforeStage?.length && moment.beforeStage.some(stage => achieved[stage]?.achievedAt)) {\n      return false;\n    }\n    return true;\n  }\n\n  private resolveTarget(moment: ValueMoment, principal: ValueMomentPrincipal): { resourceType: ReturnType<ProgressionStateStoreBackendService['resolveScopeTarget']>['resourceType']; scopeId: string } | undefined {\n    const { resourceType, scopeId } = this.progressionStateStore.resolveScopeTarget(\n      progressionScopeFor(moment.scope),\n      principal.userId,\n      principal.organizationId,\n    );\n    return scopeId ? { resourceType, scopeId } : undefined;\n  }\n\n  /**\n   * Invoke the moment's registered backend handler, if it declared one.\n   *\n   * Failures are logged and swallowed: the moment IS achieved and the record is already written, so\n   * a handler that throws must not make the achievement look like it did not happen. The registry\n   * warns on its own when a declared handler was never registered.\n   */\n  private async invokeAchievementHandler(moment: ValueMoment, scopeEntityId: string): Promise<void> {\n    const handlerRef = moment.onAchieved?.backendHandler;\n    if (!handlerRef) return;\n    try {\n      await this.handlerRegistry.invokeHandler(handlerRef, {\n        momentIdentifier: moment.identifier,\n        role: moment.role,\n        scope: moment.scope,\n        scopeEntityId,\n        achievedAt: Date.now(),\n        executionContext: undefined,\n      });\n    } catch (error) {\n      this.logger.warn('[ValueMomentEngine] onAchieved handler failed', {\n        moment: moment.identifier,\n        handlerRef,\n        error: describeCaughtError(error),\n      });\n    }\n  }\n\n  // =====================================================\n  // Read / explicit write\n  // =====================================================\n\n  /**\n   * The moments this principal has achieved.\n   *\n   * Returns the USER scope's moments, plus the ORGANIZATION scope's when the execution carries one —\n   * both are \"what this person has reached\", and the frontend's achieved-set is not scope-split.\n   */\n  public async getAchievedMoments(principal: ValueMomentPrincipal): Promise<{ momentIdentifier: string; achievedAt: Date }[]> {\n    const results: { momentIdentifier: string; achievedAt: Date }[] = [];\n\n    for (const scope of [ProgressionScope.USER, ProgressionScope.ORGANIZATION]) {\n      const { resourceType, scopeId } = this.progressionStateStore.resolveScopeTarget(scope, principal.userId, principal.organizationId);\n      if (!scopeId) continue;\n      const state = await this.progressionStateStore.loadOrCreate(resourceType, scopeId);\n      for (const [identifier, record] of Object.entries(state.valueMomentsAchieved ?? {})) {\n        if (record.achievedAt) results.push({ momentIdentifier: identifier, achievedAt: record.achievedAt });\n      }\n    }\n\n    return results;\n  }\n\n  /**\n   * Record a moment as achieved directly — the frontend's `backendSync` path, where the frontend\n   * evaluated a signal the backend cannot see (a view visit, a feature access) and reports it.\n   *\n   * The scope comes from the DEFINITION when the moment is registered, and from the caller only when\n   * it is not: an application may sync a moment the backend does not know about, and refusing it\n   * would lose the frontend's evaluation entirely.\n   */\n  public async markAchieved(\n    momentIdentifier: string,\n    principal: ValueMomentPrincipal,\n    requestedScope?: string,\n  ): Promise<ValueMomentWriteOutcome> {\n    const definition = this.definitionRegistry.getDefinition(momentIdentifier);\n    const scope = (definition?.scope ?? requestedScope ?? ValueMomentScope.USER) as ValueMomentScope;\n\n    const { resourceType, scopeId } = this.progressionStateStore.resolveScopeTarget(\n      progressionScopeFor(scope),\n      principal.userId,\n      principal.organizationId,\n    );\n    if (!scopeId) return ValueMomentWriteOutcome.SCOPE_UNAVAILABLE;\n\n    const scopeFilter = this.progressionStateStore.scopeFilter(resourceType, scopeId);\n    await this.progressionStateStore.loadOrCreate(resourceType, scopeId);\n\n    const updated = await this.repositoriesRegistry.atomicGuardedMutation<ProgressionState>(\n      resourceType,\n      {\n        ...scopeFilter,\n        [`valueMomentsAchieved.${momentIdentifier}.achievedAt`]: { $exists: false },\n      },\n      {\n        set: {\n          [`valueMomentsAchieved.${momentIdentifier}`]: {\n            // Every signal the definition declares, because the frontend reporting an achievement is\n            // reporting the WHOLE moment rather than one of its signals. An unregistered moment has\n            // no signals to name, and the empty list is honest about that.\n            signalsObserved: definition?.signals.map(valueSignalKey) ?? [],\n            achievedAt: new Date(),\n          },\n        },\n      },\n    );\n\n    if (!updated) {\n      const after = await this.progressionStateStore.loadOrCreate(resourceType, scopeId);\n      return after.valueMomentsAchieved?.[momentIdentifier]?.achievedAt\n        ? ValueMomentWriteOutcome.ALREADY_ACHIEVED\n        : ValueMomentWriteOutcome.NOT_PERSISTED;\n    }\n\n    if (definition) await this.invokeAchievementHandler(definition, scopeId);\n    return ValueMomentWriteOutcome.RECORDED;\n  }\n}\n"]}

package/dist/esm/monitoring/analytics/services/value-moment-handler-registry.backend.service.d.ts

@@ -7,12 +7,21 @@ export interface ValueMomentAchievementContext {
     achievedAt: number;
     executionContext: unknown;
 }
+/**
+ * What a value moment's `onAchieved.backendHandler` names.
+ *
+ * Named rather than written inline at each site so the startup registration option, the registry's
+ * map and `resolveHandler`'s return type are one declaration — three copies of a function signature
+ * is three places for it to drift, and the drift would be a runtime shape mismatch rather than a
+ * type error, because the ref is a string.
+ */
+export type ValueMomentAchievementHandler = (context: ValueMomentAchievementContext) => Promise<void>;
 export declare class ValueMomentHandlerRegistryBackendService {
     private logger;
     private handlers;
     constructor(logger: LoggerService);
-    registerHandler(identifier: string, handler: (context: ValueMomentAchievementContext) => Promise<void>): void;
-    resolveHandler(identifier: string): ((context: ValueMomentAchievementContext) => Promise<void>) | undefined;
+    registerHandler(identifier: string, handler: ValueMomentAchievementHandler): void;
+    resolveHandler(identifier: string): ValueMomentAchievementHandler | undefined;
     invokeHandler(identifier: string, context: ValueMomentAchievementContext): Promise<void>;
 }
 //# sourceMappingURL=value-moment-handler-registry.backend.service.d.ts.map

package/dist/esm/monitoring/analytics/services/value-moment-handler-registry.backend.service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"value-moment-handler-registry.backend.service.d.ts","sourceRoot":"","sources":["../../../../../../src/monitoring/analytics/services/value-moment-handler-registry.backend.service.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,8DAA8D,CAAC;AAE7F,MAAM,WAAW,6BAA6B;IAC5C,gBAAgB,EAAE,MAAM,CAAC;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,OAAO,CAAC;CAC3B;AAED,qBACa,wCAAwC;IAId,OAAO,CAAC,MAAM;IAHnD,OAAO,CAAC,QAAQ,CAAgF;gBAGnD,MAAM,EAAE,aAAa;IAGlE,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,OAAO,EAAE,6BAA6B,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI;IAI7G,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,CAAC,CAAC,OAAO,EAAE,6BAA6B,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG,SAAS;IAIrG,aAAa,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,6BAA6B,GAAG,OAAO,CAAC,IAAI,CAAC;CAQ/F"}
+{"version":3,"file":"value-moment-handler-registry.backend.service.d.ts","sourceRoot":"","sources":["../../../../../src/monitoring/analytics/services/value-moment-handler-registry.backend.service.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,8DAA8D,CAAC;AAE7F,MAAM,WAAW,6BAA6B;IAC5C,gBAAgB,EAAE,MAAM,CAAC;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,OAAO,CAAC;CAC3B;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,6BAA6B,GAAG,CAAC,OAAO,EAAE,6BAA6B,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AAEtG,qBACa,wCAAwC;IAId,OAAO,CAAC,MAAM;IAHnD,OAAO,CAAC,QAAQ,CAAoD;gBAGvB,MAAM,EAAE,aAAa;IAGlE,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,6BAA6B,GAAG,IAAI;IAIjF,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,6BAA6B,GAAG,SAAS;IAIvE,aAAa,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,6BAA6B,GAAG,OAAO,CAAC,IAAI,CAAC;CAQ/F"}

package/dist/esm/monitoring/analytics/services/value-moment-handler-registry.backend.service.js.map

@@ -1 +1 @@
-{"version":3,"file":"value-moment-handler-registry.backend.service.js","sourceRoot":"","sources":["../../../../../../src/monitoring/analytics/services/value-moment-handler-registry.backend.service.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAAE,kBAAkB,EAAE,MAAM,gDAAgD,CAAC;AACpF,OAAO,EAAE,aAAa,EAAE,MAAM,8DAA8D,CAAC;AAYtF,IAAM,wCAAwC,GAA9C,MAAM,wCAAwC;IAIN;IAHrC,QAAQ,GAAG,IAAI,GAAG,EAAqE,CAAC;IAEhG,YAC6C,MAAqB;QAArB,WAAM,GAAN,MAAM,CAAe;IAC/D,CAAC;IAEJ,eAAe,CAAC,UAAkB,EAAE,OAAkE;QACpG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;IACzC,CAAC;IAED,cAAc,CAAC,UAAkB;QAC/B,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;IACvC,CAAC;IAED,KAAK,CAAC,aAAa,CAAC,UAAkB,EAAE,OAAsC;QAC5E,MAAM,OAAO,GAAG,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;QAChD,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,2DAA2D,UAAU,EAAE,CAAC,CAAC;YAC1F,OAAO;QACT,CAAC;QACD,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;IACzB,CAAC;CACF,CAAA;AAvBY,wCAAwC;IADpD,UAAU,EAAE;IAKR,WAAA,MAAM,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAA;qCAAiB,aAAa;GAJvD,wCAAwC,CAuBpD","sourcesContent":["import { injectable, inject } from 'inversify';\nimport { SAAS_SERVICE_TYPES } from '~wildo-backend-lib/inject/models/service-types';\nimport { LoggerService } from '~wildo-backend-lib/monitoring/logger/services/logger.service';\n\nexport interface ValueMomentAchievementContext {\n  momentIdentifier: string;\n  role: string;\n  scope: string;\n  scopeEntityId: string;\n  achievedAt: number;\n  executionContext: unknown;\n}\n\n@injectable()\nexport class ValueMomentHandlerRegistryBackendService {\n  private handlers = new Map<string, (context: ValueMomentAchievementContext) => Promise<void>>();\n\n  constructor(\n    @inject(SAAS_SERVICE_TYPES.Logger) private logger: LoggerService,\n  ) {}\n\n  registerHandler(identifier: string, handler: (context: ValueMomentAchievementContext) => Promise<void>): void {\n    this.handlers.set(identifier, handler);\n  }\n\n  resolveHandler(identifier: string): ((context: ValueMomentAchievementContext) => Promise<void>) | undefined {\n    return this.handlers.get(identifier);\n  }\n\n  async invokeHandler(identifier: string, context: ValueMomentAchievementContext): Promise<void> {\n    const handler = this.resolveHandler(identifier);\n    if (!handler) {\n      this.logger.warn(`[ValueMomentHandlerRegistry] No handler registered for: ${identifier}`);\n      return;\n    }\n    await handler(context);\n  }\n}\n"]}
+{"version":3,"file":"value-moment-handler-registry.backend.service.js","sourceRoot":"","sources":["../../../../../src/monitoring/analytics/services/value-moment-handler-registry.backend.service.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAAE,kBAAkB,EAAE,MAAM,gDAAgD,CAAC;AACpF,OAAO,EAAE,aAAa,EAAE,MAAM,8DAA8D,CAAC;AAsBtF,IAAM,wCAAwC,GAA9C,MAAM,wCAAwC;IAIN;IAHrC,QAAQ,GAAG,IAAI,GAAG,EAAyC,CAAC;IAEpE,YAC6C,MAAqB;QAArB,WAAM,GAAN,MAAM,CAAe;IAC/D,CAAC;IAEJ,eAAe,CAAC,UAAkB,EAAE,OAAsC;QACxE,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;IACzC,CAAC;IAED,cAAc,CAAC,UAAkB;QAC/B,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;IACvC,CAAC;IAED,KAAK,CAAC,aAAa,CAAC,UAAkB,EAAE,OAAsC;QAC5E,MAAM,OAAO,GAAG,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;QAChD,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,2DAA2D,UAAU,EAAE,CAAC,CAAC;YAC1F,OAAO;QACT,CAAC;QACD,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;IACzB,CAAC;CACF,CAAA;AAvBY,wCAAwC;IADpD,UAAU,EAAE;IAKR,WAAA,MAAM,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAA;qCAAiB,aAAa;GAJvD,wCAAwC,CAuBpD","sourcesContent":["import { injectable, inject } from 'inversify';\nimport { SAAS_SERVICE_TYPES } from '~wildo-backend-lib/inject/models/service-types';\nimport { LoggerService } from '~wildo-backend-lib/monitoring/logger/services/logger.service';\n\nexport interface ValueMomentAchievementContext {\n  momentIdentifier: string;\n  role: string;\n  scope: string;\n  scopeEntityId: string;\n  achievedAt: number;\n  executionContext: unknown;\n}\n\n/**\n * What a value moment's `onAchieved.backendHandler` names.\n *\n * Named rather than written inline at each site so the startup registration option, the registry's\n * map and `resolveHandler`'s return type are one declaration — three copies of a function signature\n * is three places for it to drift, and the drift would be a runtime shape mismatch rather than a\n * type error, because the ref is a string.\n */\nexport type ValueMomentAchievementHandler = (context: ValueMomentAchievementContext) => Promise<void>;\n\n@injectable()\nexport class ValueMomentHandlerRegistryBackendService {\n  private handlers = new Map<string, ValueMomentAchievementHandler>();\n\n  constructor(\n    @inject(SAAS_SERVICE_TYPES.Logger) private logger: LoggerService,\n  ) {}\n\n  registerHandler(identifier: string, handler: ValueMomentAchievementHandler): void {\n    this.handlers.set(identifier, handler);\n  }\n\n  resolveHandler(identifier: string): ValueMomentAchievementHandler | undefined {\n    return this.handlers.get(identifier);\n  }\n\n  async invokeHandler(identifier: string, context: ValueMomentAchievementContext): Promise<void> {\n    const handler = this.resolveHandler(identifier);\n    if (!handler) {\n      this.logger.warn(`[ValueMomentHandlerRegistry] No handler registered for: ${identifier}`);\n      return;\n    }\n    await handler(context);\n  }\n}\n"]}