@dailephd/my-frontend-observer 0.8.1

package/dist/domain/comparisonEngine.d.ts

@@ -0,0 +1,76 @@
+import type { ObservationArtifact, TargetEvidenceRecord } from './schema.js';
+import type { ComparisonConfig, ComparabilityResult, ComparabilityReason, ComparabilityReasonCode, TargetConfigurationChange, ExpectedDependencyDeclaration, ExpectedDependencyEvidence, ComparisonArtifact } from './comparison.js';
+/**
+ * Configuration-change evidence: `removed`/`locator-changed` in before's
+ * configured order, then `added` in after's configured order (Batch 1's
+ * frozen ordering guidance) - never a source of appeared/disappeared
+ * rendered-state differences by itself.
+ */
+export declare function compareTargetConfiguration(before: ObservationArtifact, after: ObservationArtifact): TargetConfigurationChange[];
+/**
+ * v0.7 Prompt 4 shared pure dimension-comparison rule, used by both
+ * `evaluateComparability` below (v0.4, ObservationArtifact <-> ObservationArtifact -
+ * both sides always technically present, but `explicitState` sub-fields are
+ * each independently optional) and
+ * `domain/externalReferenceCompatibility.ts#evaluateReferenceCandidateCompatibility`
+ * (v0.7, where the reference-side value is optional by construction - a
+ * reference need not declare an applicable viewport/theme/state at all).
+ * One rule, three outcomes, matching request section 16 G/H/I exactly:
+ * both sides present and equal -> no reason at all (the existing "matching
+ * dimensions produce no reason" convention); both present and different ->
+ * the blocking mismatch reason; either side absent -> the unassessed
+ * reason (never silently treated as compatible, never a fabricated
+ * mismatch merely because one side omitted the dimension).
+ */
+export declare function assessOptionalComparabilityDimension(mismatchCode: ComparabilityReasonCode, unassessedCode: ComparabilityReasonCode, beforeValue: string | undefined, afterValue: string | undefined, mismatchMessage: (beforeValue: string, afterValue: string) => string, unassessedMessage: string): ComparabilityReason | undefined;
+/**
+ * Evaluates comparability before any rendered difference is calculated
+ * (Batch 1's frozen `ComparabilityResult`/reason vocabulary). Hard
+ * incompatibilities (`blocking`) force `incomparable`; producer/browser
+ * version and target-configuration mismatches are `warning`-only. The three
+ * state dimensions (theme, authenticated-state, application-state) are
+ * assessed - matching or blocking-mismatched - whenever both observations
+ * declare that dimension via v0.7 Prompt 4's `requestConfig.explicitState`;
+ * otherwise (the entire pre-Prompt-4 case, and any Prompt-4-era observation
+ * that simply omits a dimension) they remain `unassessed`, exactly as
+ * before - never silently claimed identical.
+ */
+export declare function evaluateComparability(before: ObservationArtifact, after: ObservationArtifact): ComparabilityResult;
+/**
+ * v0.7 Prompt 5 additive export (previously module-private): the canonical
+ * classification of one configured target's resolution outcome, reused
+ * as-is by `domain/externalReferenceRuntimeBinding.ts` so reference-region/
+ * runtime-target binding evaluation never re-derives or duplicates this
+ * "how do I read a TargetEvidenceRecord's resolution" rule.
+ */
+export type TargetPresence = 'matched' | 'not-found' | 'ambiguous' | 'unavailable';
+export declare function targetPresence(record: TargetEvidenceRecord | undefined): TargetPresence;
+/**
+ * Evaluates only explicitly-declared dependencies (`config.expectedDependencies`,
+ * in declared order) - never synthesizes a declaration from observed
+ * co-change (Batch 1's hard non-causal boundary). Each declared side is
+ * evaluated independently from the target's own before/after geometry;
+ * `unavailable` when either side's required property evidence cannot be
+ * read, `contradictory-to-declaration` when either side's actual direction
+ * is the strict opposite of what was declared, `consistent` when both sides
+ * match their declared direction, `not-observed` otherwise. No causal claim
+ * is ever produced.
+ */
+export declare function evaluateExpectedDependencies(before: ObservationArtifact, after: ObservationArtifact, declarations: readonly ExpectedDependencyDeclaration[], tolerance: number): ExpectedDependencyEvidence[];
+export type CompareObservationsResult = {
+    ok: true;
+    artifact: ComparisonArtifact;
+} | {
+    ok: false;
+    reason: string;
+};
+/**
+ * The one canonical pure comparison entry point (real Chromium ->
+ * ObservationArtifact -> relationship derivation -> **comparability ->
+ * comparison** -> ComparisonArtifact, see docs/ARCHITECTURE.md). Comparison
+ * is ordered: `compareObservations(a, b)` and `compareObservations(b, a)`
+ * produce different `comparisonRequestId`s and reversed-sign
+ * moved/resized deltas - `before`/`after` are never treated as an
+ * unordered pair.
+ */
+export declare function compareObservations(before: ObservationArtifact, after: ObservationArtifact, configInput?: Partial<ComparisonConfig>): CompareObservationsResult;