niceeval 0.12.2-canary.31 → 0.13.0

package/dist/analysis/api.cjs

@@ -0,0 +1,689 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sandboxHistoryView = exports.sourcesView = exports.sourceNavigationView = exports.fileChangesView = exports.attemptObservabilityView = exports.attemptEvidenceView = void 0;
+exports.aggregate = aggregate;
+exports.aggregateEffect = aggregateEffect;
+exports.query = query;
+exports.queryEffect = queryEffect;
+const effect_1 = require("effect");
+const attempt_locator_ts_1 = require("../attempt-locator.cjs");
+const bindings_ts_1 = require("./bindings.cjs");
+const definitions_ts_1 = require("./definitions.cjs");
+const cost_ts_1 = require("./cost.cjs");
+const cost_projection_ts_1 = require("./cost-projection.cjs");
+const contracts_ts_1 = require("./contracts.cjs");
+const capability_ts_1 = require("../sample/capability.cjs");
+const domainViewRequestTypeId = Symbol("niceeval.analysis.DomainViewRequest");
+const publishedDomainViewBindings = new WeakMap();
+function publishedDomainViewRequest(binding) {
+    const request = Object.freeze({
+        kind: "domain-view-request",
+        id: binding.id,
+        [domainViewRequestTypeId]: (value) => value,
+    });
+    publishedDomainViewBindings.set(request, Object.freeze({
+        read: (sample, locator) => (0, capability_ts_1.readBuiltinDomainView)(sample, binding, locator),
+    }));
+    return request;
+}
+/** Closed Assertions / evidence material for each included Attempt. */
+exports.attemptEvidenceView = publishedDomainViewRequest(bindings_ts_1.attemptEvidenceDomainBinding);
+/** Closed conversation, commands, usage, timing and diagnostics per Attempt. */
+exports.attemptObservabilityView = publishedDomainViewRequest(bindings_ts_1.attemptObservabilityDomainBinding);
+/** Closed attempt-owned FileChanges projection. */
+exports.fileChangesView = publishedDomainViewRequest(bindings_ts_1.fileChangesDomainBinding);
+/** Closed physical send-to-source and send-to-timing navigation rows. */
+exports.sourceNavigationView = publishedDomainViewRequest(bindings_ts_1.sourceNavigationDomainBinding);
+/** Closed origin-run Sources projection for each included Attempt. */
+exports.sourcesView = publishedDomainViewRequest(bindings_ts_1.sourcesDomainBinding);
+/** Sandbox command/timing/diagnostic history projected from Observability. */
+exports.sandboxHistoryView = publishedDomainViewRequest(bindings_ts_1.sandboxHistoryDomainBinding);
+function aggregate(sample, request) {
+    const capture = (0, capability_ts_1.currentAnalysisIssueCapture)(sample);
+    return (0, capability_ts_1.runSamplePromise)(sample, aggregateEffect(sample, request, capture));
+}
+/**
+ * Scoped host operation behind the public Promise facade. It is intentionally
+ * absent from the `niceeval/analysis` export surface.
+ *
+ * @internal
+ */
+function aggregateEffect(sample, request, capture) {
+    return effect_1.Effect.flatMap((0, capability_ts_1.assertSampleOpen)(sample), () => {
+        const inferred = inferAggregatePopulation(request);
+        if (inferred instanceof Error)
+            return effect_1.Effect.fail(requestError(inferred.message));
+        return effect_1.Effect.map(executeFrame(sample, {
+            kind: "frame",
+            population: inferred,
+            by: request.by,
+            measures: request.values,
+        }, capture), (frame) => frame.rows);
+    });
+}
+function query(sample, request) {
+    const capture = (0, capability_ts_1.currentAnalysisIssueCapture)(sample);
+    const operation = request.kind === "frame"
+        ? queryEffect(sample, request, capture)
+        : queryEffect(sample, request, capture);
+    return (0, capability_ts_1.runSamplePromise)(sample, operation);
+}
+/** @internal */
+function queryEffect(sample, request, capture) {
+    if (request.kind === "frame")
+        return executeFrame(sample, request, capture);
+    const binding = publishedDomainViewBindings.get(request.view);
+    if (binding === undefined) {
+        return effect_1.Effect.flatMap((0, capability_ts_1.assertSampleOpen)(sample), () => effect_1.Effect.fail(requestError(`DomainView request ${request.view.id} is not published by Analysis`)));
+    }
+    return effect_1.Effect.flatMap((0, capability_ts_1.assertSampleOpen)(sample), () => {
+        const locator = request.locator;
+        if (locator !== undefined) {
+            if (typeof locator !== "string" || !(0, attempt_locator_ts_1.parseAttemptLocator)(locator).valid) {
+                return effect_1.Effect.fail(requestError("DomainView locator must be a canonical Attempt locator"));
+            }
+            const selected = sample.snapshot.slots.some((slot) => slot.state === "included" && slot.attempt.locator === locator);
+            if (!selected) {
+                return effect_1.Effect.fail(requestError("DomainView locator does not belong to the current Sample"));
+            }
+        }
+        return effect_1.Effect.map(binding.read(sample, locator), (view) => {
+            (0, capability_ts_1.recordAnalysisIssues)(sample, view.issues, capture);
+            return view;
+        });
+    });
+}
+/** Bound independent Record reads without serializing large Report Samples. */
+const ANALYSIS_READ_CONCURRENCY = 32;
+function executeFrame(sample, request, capture) {
+    return effect_1.Effect.suspend(() => {
+        const normalized = normalizeFrameRequest(request);
+        if (normalized instanceof Error)
+            return effect_1.Effect.fail(requestError(normalized.message));
+        return effect_1.Effect.gen(function* () {
+            yield* (0, capability_ts_1.assertSampleOpen)(sample);
+            const context = {
+                sample,
+                relationTargets: new Map(),
+                memberKeys: new Map(),
+            };
+            const groups = yield* buildGroups(context, normalized);
+            const rows = [];
+            const frameIssues = [];
+            const frameRefs = [];
+            for (const group of groups) {
+                const row = { key: group.key, ...group.coordinates };
+                const values = yield* effect_1.Effect.forEach(normalized.measures, ([name, measure]) => effect_1.Effect.map(evaluateMeasure(context, normalized.population, group.members, measure), (value) => [name, measure, value]), { concurrency: ANALYSIS_READ_CONCURRENCY });
+                for (const [name, measure, value] of values) {
+                    row[name] = value;
+                    frameIssues.push(...value.issues);
+                    frameRefs.push(...value.refs);
+                    if ((0, cost_ts_1.isCostMeasure)(measure)) {
+                        (0, capability_ts_1.recordAnalysisCostMetric)(sample, {
+                            measureId: measure.id,
+                            row: Object.freeze({ key: group.key, dimensions: group.coordinates }),
+                            metric: value,
+                        }, capture);
+                    }
+                }
+                rows.push(Object.freeze(row));
+                frameIssues.push(...group.issues);
+                frameRefs.push(...group.issues.flatMap((entry) => entry.refs));
+            }
+            const issues = freezeIssues(frameIssues);
+            const refs = dedupeRefs([...frameRefs, ...issues.flatMap((entry) => entry.refs)]);
+            const closedRows = (0, contracts_ts_1.makeClosedRows)({
+                rows,
+                identity: Object.freeze({
+                    kind: "closed-rows",
+                    id: canonicalIdentity("closed-rows", [
+                        sample.snapshot.identity.id,
+                        normalized.population.id,
+                        normalized.dimensions.map(([name, dimension]) => [name, dimension.id]),
+                        normalized.measures.map(([name, measure]) => [name, measure.id]),
+                        groups.map((group) => Object.freeze([
+                            group.key,
+                            Object.freeze(group.members
+                                .map((member) => (0, definitions_ts_1.populationMembersState)(normalized.population.members).key(member))
+                                .sort(compareCanonicalCodeUnits)),
+                        ])),
+                    ]),
+                }),
+                issues,
+                refs,
+            });
+            const frame = Object.freeze({
+                kind: "semantic-frame",
+                sample: sample.snapshot.identity,
+                population: (0, definitions_ts_1.populationIdentity)(normalized.population),
+                rows: closedRows,
+                issues,
+                refs,
+            });
+            (0, capability_ts_1.recordAnalysisIssues)(sample, issues, capture);
+            return frame;
+        });
+    });
+}
+function inferAggregatePopulation(request) {
+    const candidates = [];
+    let hasCostMeasure = false;
+    try {
+        for (const dimension of Object.values(request.by)) {
+            if (!isDimension(dimension))
+                return new Error("aggregate by must contain only Dimensions");
+            candidates.push(dimension.population);
+        }
+        for (const measure of Object.values(request.values)) {
+            const cost = (0, cost_ts_1.isCostMeasure)(measure);
+            if (!cost && !isMeasure(measure))
+                return new Error("aggregate values must contain only Measures");
+            if (cost) {
+                // The CostMeasure descriptor, rather than a foreign package's
+                // Population object or a string id, binds it to this package's
+                // logical-Slot catalog.
+                hasCostMeasure = true;
+            }
+            else {
+                candidates.push(measure.population);
+            }
+        }
+    }
+    catch (error) {
+        return new Error(errorMessage(error));
+    }
+    if (hasCostMeasure)
+        return definitions_ts_1.logicalSlots;
+    const first = candidates[0];
+    return first === undefined ? new Error("aggregate needs at least one Dimension or Measure") : first;
+}
+function normalizeFrameRequest(request) {
+    if (request === null || typeof request !== "object" || request.kind !== "frame") {
+        return new Error("frame request must have kind frame");
+    }
+    try {
+        if (!isPlainObject(request.by) || !isPlainObject(request.measures)) {
+            return new Error("frame by and measures must be records");
+        }
+        const dimensions = Object.entries(request.by);
+        const measures = Object.entries(request.measures);
+        if (measures.length === 0)
+            return new Error("frame request needs at least one Measure");
+        const ids = new Set();
+        for (const [, dimension] of dimensions) {
+            if (!isDimension(dimension))
+                return new Error("frame by must contain only Dimensions");
+            if (ids.has(dimension.id))
+                return new Error(`Dimension identity collision: ${dimension.id}`);
+            ids.add(dimension.id);
+        }
+        for (const [, measure] of measures) {
+            const cost = (0, cost_ts_1.isCostMeasure)(measure);
+            if (!cost && !isMeasure(measure))
+                return new Error("frame measures must contain only Measures");
+            const descriptor = measure;
+            if (ids.has(descriptor.id))
+                return new Error(`Measure identity collision: ${descriptor.id}`);
+            ids.add(descriptor.id);
+        }
+        const typedDimensions = dimensions.filter((entry) => isDimension(entry[1]));
+        const typedMeasures = measures.filter((entry) => (0, cost_ts_1.isCostMeasure)(entry[1]) || isMeasure(entry[1]));
+        // Explicit query Population capabilities stay package-local. Cross-package
+        // CostMeasure support is limited to aggregate()'s Measure-driven inference;
+        // a string id cannot author a new Population capability here.
+        (0, definitions_ts_1.populationIdentity)(request.population);
+        const population = request.population;
+        for (const [, descriptor] of [...typedDimensions, ...typedMeasures]) {
+            const targetPopulation = (0, cost_ts_1.isCostMeasure)(descriptor)
+                ? definitions_ts_1.logicalSlots
+                : descriptor.population;
+            if (samePopulationMembers(population, targetPopulation))
+                continue;
+            const links = (0, definitions_ts_1.registeredRelations)().filter((relation) => relation.from === population && relation.to === targetPopulation);
+            if (links.length !== 1) {
+                return new Error(`No unambiguous Relation connects ${population.id} to ${targetPopulation.id}`);
+            }
+        }
+        return Object.freeze({
+            population,
+            dimensions: Object.freeze(typedDimensions),
+            measures: Object.freeze(typedMeasures),
+        });
+    }
+    catch (error) {
+        return new Error(errorMessage(error));
+    }
+}
+function buildGroups(context, request) {
+    return effect_1.Effect.gen(function* () {
+        const baseMembers = yield* (0, definitions_ts_1.populationMembersState)(request.population.members).enumerate(context.sample);
+        const groups = new Map();
+        for (const member of baseMembers) {
+            const coordinates = {};
+            const issues = [];
+            for (const [name, dimension] of request.dimensions) {
+                const resolved = yield* resolveMember(context, request.population, member, dimension.population);
+                issues.push(...resolved.issues);
+                if (resolved.member === undefined) {
+                    coordinates[name] = null;
+                    continue;
+                }
+                try {
+                    const value = (0, definitions_ts_1.dimensionState)(dimension).value(resolved.member);
+                    if (!isDimensionValue(value)) {
+                        issues.push(issue("input-invalid", `Dimension ${dimension.id} returned a non-serializable value`));
+                        coordinates[name] = null;
+                    }
+                    else {
+                        coordinates[name] = value;
+                    }
+                }
+                catch (error) {
+                    issues.push(issue("input-invalid", `Dimension ${dimension.id} failed: ${errorMessage(error)}`));
+                    coordinates[name] = null;
+                }
+            }
+            const key = groupKey(coordinates);
+            const previous = groups.get(key);
+            if (previous === undefined) {
+                groups.set(key, {
+                    key,
+                    coordinates: Object.freeze({ ...coordinates }),
+                    members: [member],
+                    issues,
+                });
+            }
+            else {
+                previous.members.push(member);
+                previous.issues.push(...issues);
+            }
+        }
+        return Object.freeze([...groups.values()].sort((left, right) => compareCanonicalCodeUnits(left.key, right.key)));
+    });
+}
+function evaluateMeasure(context, sourcePopulation, sourceMembers, measure) {
+    return effect_1.Effect.gen(function* () {
+        const cost = (0, cost_ts_1.costMeasureState)(measure);
+        if (cost !== undefined) {
+            return yield* evaluateCostMeasure(context, sourcePopulation, sourceMembers, cost);
+        }
+        const state = measureStateFor(measure);
+        const denominator = (0, definitions_ts_1.denominatorState)(state.denominator);
+        const resolved = [];
+        const targetMembers = [];
+        const targets = yield* effect_1.Effect.forEach(sourceMembers, (sourceMember) => resolveMember(context, sourcePopulation, sourceMember, measure.population), { concurrency: ANALYSIS_READ_CONCURRENCY });
+        for (const target of targets) {
+            if (target.member === undefined) {
+                resolved.push(failedReduced(target.issues));
+            }
+            else {
+                targetMembers.push(target.member);
+            }
+        }
+        const expectedMembers = denominator.members(targetMembers);
+        const observations = yield* effect_1.Effect.forEach(expectedMembers, (member) => effect_1.Effect.map((0, definitions_ts_1.analysisInputState)(state.input).read(context.sample, member), (observation) => {
+            const withinAttempt = reduce((0, definitions_ts_1.reductionState)(state.withinAttempt).kind, [fromObservation(observation)]);
+            return reduce((0, definitions_ts_1.reductionState)(state.withinSlot).kind, [withinAttempt]);
+        }), { concurrency: ANALYSIS_READ_CONCURRENCY });
+        resolved.push(...observations);
+        const across = reduce((0, definitions_ts_1.reductionState)(state.acrossSlots).kind, resolved);
+        return metricValue({
+            measure,
+            slots: resolved,
+            across,
+            total: resolved.length,
+            basis: denominator.basis,
+            enforceSameProducer: (0, definitions_ts_1.producerPolicyIsRequired)(state.producers),
+        });
+    });
+}
+function evaluateCostMeasure(context, sourcePopulation, sourceMembers, state) {
+    return effect_1.Effect.gen(function* () {
+        const resolved = yield* effect_1.Effect.forEach(sourceMembers, (member) => resolveMember(context, sourcePopulation, member, definitions_ts_1.logicalSlots), { concurrency: ANALYSIS_READ_CONCURRENCY });
+        const relationIssues = freezeIssues(resolved.flatMap((entry) => entry.issues));
+        const keys = new Set(resolved.flatMap((entry) => entry.member === undefined ? [] : [logicalSlotKey(entry.member)]));
+        const entries = yield* (0, capability_ts_1.readCostProjection)(context.sample, state.profile);
+        const reduced = (0, cost_projection_ts_1.aggregateCostProjection)(state.profile, entries.filter((entry) => keys.has(logicalSlotKey(entry.slot))), state.mode);
+        return Object.freeze({
+            value: reduced.value,
+            state: reduced.projection.state,
+            samples: reduced.samples,
+            total: reduced.total,
+            basis: "slot",
+            issues: relationIssues,
+            refs: dedupeRefs([...reduced.refs, ...relationIssues.flatMap((entry) => entry.refs)]),
+            format: "currency-usd",
+            better: "lower",
+            projection: reduced.projection,
+        });
+    });
+}
+function logicalSlotKey(slot) {
+    return `${slot.runId}\u0000${slot.slotId}`;
+}
+function resolveMember(context, from, member, to) {
+    if (samePopulationMembers(from, to)) {
+        return effect_1.Effect.succeed(Object.freeze({ member, issues: Object.freeze([]) }));
+    }
+    const candidates = (0, definitions_ts_1.registeredRelations)().filter((relation) => relation.from === from && relation.to === to);
+    if (candidates.length !== 1) {
+        return effect_1.Effect.succeed(unmatched(`No unambiguous Relation connects ${from.id} to ${to.id}`));
+    }
+    const relation = candidates[0];
+    let target;
+    try {
+        target = (0, definitions_ts_1.relationState)(relation).match(member);
+    }
+    catch (error) {
+        return effect_1.Effect.succeed(unmatched(`Relation ${relation.id} failed: ${errorMessage(error)}`));
+    }
+    if (target === null)
+        return effect_1.Effect.succeed(unmatched(`Relation ${relation.id} did not match a target`));
+    return effect_1.Effect.flatMap(memberKeys(context, to), (targets) => {
+        let targetKey;
+        let sourceKey;
+        try {
+            targetKey = (0, definitions_ts_1.populationMembersState)(to.members).key(target);
+            sourceKey = (0, definitions_ts_1.populationMembersState)(from.members).key(member);
+        }
+        catch (error) {
+            return effect_1.Effect.succeed(unmatched(`Relation ${relation.id} returned an invalid target: ${errorMessage(error)}`));
+        }
+        if (!targets.includes(targetKey)) {
+            return effect_1.Effect.succeed(unmatched(`Relation ${relation.id} returned a target outside ${to.id}`));
+        }
+        if (relation.cardinality === "one-to-one") {
+            let seen = context.relationTargets.get(relation);
+            if (seen === undefined) {
+                seen = new Map();
+                context.relationTargets.set(relation, seen);
+            }
+            const previous = seen.get(targetKey);
+            if (previous !== undefined && previous !== sourceKey) {
+                return effect_1.Effect.succeed(unmatched(`Relation ${relation.id} violates one-to-one cardinality`));
+            }
+            seen.set(targetKey, sourceKey);
+        }
+        return effect_1.Effect.succeed(Object.freeze({ member: target, issues: Object.freeze([]) }));
+    });
+}
+function memberKeys(context, population) {
+    const cached = context.memberKeys.get(population);
+    if (cached !== undefined)
+        return effect_1.Effect.succeed(cached);
+    return effect_1.Effect.map((0, definitions_ts_1.populationMembersState)(population.members).enumerate(context.sample), (members) => {
+        const keys = Object.freeze(members.map((member) => (0, definitions_ts_1.populationMembersState)(population.members).key(member)));
+        context.memberKeys.set(population, keys);
+        return keys;
+    });
+}
+function fromObservation(observation) {
+    if (observation.state === "value") {
+        if (observation.value === null) {
+            return Object.freeze({
+                state: "empty",
+                issues: Object.freeze([]),
+                refs: observation.refs,
+                producers: observation.producer === undefined ? Object.freeze([]) : Object.freeze([observation.producer]),
+            });
+        }
+        return Object.freeze({
+            state: "value",
+            value: observation.value,
+            issues: Object.freeze([]),
+            refs: observation.refs,
+            producers: observation.producer === undefined ? Object.freeze([]) : Object.freeze([observation.producer]),
+        });
+    }
+    return Object.freeze({
+        state: observation.state,
+        issues: observation.issues,
+        refs: observation.refs,
+        producers: observation.producer === undefined ? Object.freeze([]) : Object.freeze([observation.producer]),
+    });
+}
+function reduce(kind, entries) {
+    const metadata = reductionMetadata(entries);
+    if (entries.some((entry) => entry.state === "failed")) {
+        return failedReduced(metadata.issues, metadata.refs, metadata.producers);
+    }
+    const values = entries.filter((entry) => entry.state === "value");
+    if (values.length === 0) {
+        if (entries.some((entry) => entry.state === "missing")) {
+            return missingReduced(metadata.issues, metadata.refs, metadata.producers);
+        }
+        if (entries.some((entry) => entry.state === "unsupported")) {
+            return unsupportedReduced(metadata.issues, metadata.refs, metadata.producers);
+        }
+        return emptyReduced(metadata.issues, metadata.refs, metadata.producers);
+    }
+    try {
+        switch (kind) {
+            case "one-value":
+                if (values.length !== 1)
+                    return failedReduced([
+                        ...metadata.issues,
+                        issue("reduction-failed", "oneValue received more than one input"),
+                    ], metadata.refs, metadata.producers);
+                return valueReduced(values[0].value, metadata.issues, metadata.refs, metadata.producers);
+            case "latest-completed-attempt":
+                return valueReduced(values.at(-1).value, metadata.issues, metadata.refs, metadata.producers);
+            case "sum": {
+                const sum = values.reduce((total, entry) => total + finiteNumber(entry.value), 0);
+                return valueReduced(sum, metadata.issues, metadata.refs, metadata.producers);
+            }
+            case "mean": {
+                const sum = values.reduce((total, entry) => total + finiteNumber(entry.value), 0);
+                return valueReduced(sum / values.length, metadata.issues, metadata.refs, metadata.producers);
+            }
+            case "ratio": {
+                const passed = values.reduce((total, entry) => total + (booleanValue(entry.value) ? 1 : 0), 0);
+                return valueReduced(passed / values.length, metadata.issues, metadata.refs, metadata.producers);
+            }
+        }
+    }
+    catch (error) {
+        return failedReduced([
+            ...metadata.issues,
+            issue("reduction-failed", errorMessage(error)),
+        ], metadata.refs, metadata.producers);
+    }
+}
+function metricValue(input) {
+    const issues = [...input.slots.flatMap((slot) => slot.issues), ...input.across.issues];
+    const refs = dedupeRefs([...input.slots.flatMap((slot) => slot.refs), ...input.across.refs]);
+    const producers = new Set(input.slots.flatMap((slot) => slot.producers).map((producer) => producer.id));
+    const producerConflict = input.enforceSameProducer && producers.size > 1;
+    if (producerConflict) {
+        issues.push(issue("producer-incompatible", "Measure requires one comparable producer"));
+    }
+    const frozenIssues = freezeIssues(issues);
+    const samples = input.slots.filter((slot) => slot.state === "value" || slot.state === "empty").length;
+    const common = {
+        samples,
+        total: input.total,
+        basis: input.basis,
+        issues: frozenIssues,
+        refs,
+        ...(input.measure.unit === undefined ? {} : { unit: input.measure.unit }),
+        ...(input.measure.format === undefined ? {} : { format: closeFormat(input.measure.format) }),
+        ...(input.measure.better === undefined ? {} : { better: input.measure.better }),
+    };
+    if (producerConflict || input.slots.some((slot) => slot.state === "failed") || input.across.state === "failed") {
+        return Object.freeze({ value: null, state: "failed", ...common });
+    }
+    if (input.total === 0) {
+        return Object.freeze({ value: null, state: "empty", ...common });
+    }
+    const values = input.slots.filter((slot) => slot.state === "value");
+    const unsupported = input.slots.filter((slot) => slot.state === "unsupported");
+    const missing = input.slots.filter((slot) => slot.state === "missing");
+    const empty = input.slots.filter((slot) => slot.state === "empty");
+    if (values.length === 0 && unsupported.length === input.total) {
+        return Object.freeze({ value: null, state: "unsupported", ...common });
+    }
+    if (values.length === 0 && empty.length === input.total) {
+        return Object.freeze({ value: null, state: "empty", ...common });
+    }
+    if (samples < input.total || missing.length > 0 || unsupported.length > 0) {
+        return Object.freeze({
+            value: input.across.state === "value" ? input.across.value : null,
+            state: "partial",
+            ...common,
+        });
+    }
+    if (input.across.state === "empty") {
+        return Object.freeze({ value: null, state: "empty", ...common });
+    }
+    if (input.across.state === "unsupported") {
+        return Object.freeze({ value: null, state: "unsupported", ...common });
+    }
+    if (input.across.state === "missing") {
+        return Object.freeze({ value: null, state: "partial", ...common });
+    }
+    return Object.freeze({ value: input.across.value, state: "available", ...common });
+}
+function reductionMetadata(entries) {
+    return Object.freeze({
+        issues: freezeIssues(entries.flatMap((entry) => entry.issues)),
+        refs: dedupeRefs(entries.flatMap((entry) => entry.refs)),
+        producers: Object.freeze(entries.flatMap((entry) => entry.producers)),
+    });
+}
+function valueReduced(value, issues, refs, producers) {
+    return Object.freeze({ state: "value", value, issues: freezeIssues(issues), refs, producers });
+}
+function emptyReduced(issues, refs = [], producers = []) {
+    return Object.freeze({ state: "empty", issues: freezeIssues(issues), refs: dedupeRefs(refs), producers });
+}
+function missingReduced(issues, refs = [], producers = []) {
+    return Object.freeze({ state: "missing", issues: freezeIssues(issues), refs: dedupeRefs(refs), producers });
+}
+function unsupportedReduced(issues, refs = [], producers = []) {
+    return Object.freeze({ state: "unsupported", issues: freezeIssues(issues), refs: dedupeRefs(refs), producers });
+}
+function failedReduced(issues, refs = [], producers = []) {
+    return Object.freeze({
+        state: "failed",
+        issues: freezeIssues(issues),
+        refs: dedupeRefs(refs),
+        producers: Object.freeze([...producers]),
+    });
+}
+function unmatched(message) {
+    return Object.freeze({
+        issues: Object.freeze([issue("relation-unmatched", message)]),
+    });
+}
+function issue(code, message, refs = []) {
+    return Object.freeze({ code, message, refs: dedupeRefs(refs) });
+}
+function freezeIssues(issues) {
+    const byIdentity = new Map();
+    for (const value of issues) {
+        const refs = dedupeRefs(value.refs);
+        const key = `${value.code}\u0000${value.message}\u0000${refs.map(evidenceRefIdentity).join("\u0001")}`;
+        if (!byIdentity.has(key)) {
+            byIdentity.set(key, Object.freeze({ code: value.code, message: value.message, refs }));
+        }
+    }
+    return Object.freeze([...byIdentity.entries()]
+        .sort(([left], [right]) => compareCanonicalCodeUnits(left, right))
+        .map(([, value]) => value));
+}
+function dedupeRefs(refs) {
+    const byIdentity = new Map();
+    for (const ref of refs) {
+        const key = evidenceRefIdentity(ref);
+        if (!byIdentity.has(key)) {
+            byIdentity.set(key, Object.freeze({ identity: Object.freeze({ ...ref.identity }) }));
+        }
+    }
+    return Object.freeze([...byIdentity.entries()]
+        .sort(([left], [right]) => compareCanonicalCodeUnits(left, right))
+        .map(([, value]) => value));
+}
+function evidenceRefIdentity(ref) {
+    return `${ref.identity.kind}\u0000${ref.identity.locator}`;
+}
+function closeFormat(format) {
+    if (typeof format === "string")
+        return format;
+    return Object.freeze({
+        kind: format.kind,
+        ...(format.options === undefined ? {} : { options: cloneJson(format.options) }),
+    });
+}
+function cloneJson(value) {
+    if (value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number") {
+        return value;
+    }
+    if (Array.isArray(value))
+        return Object.freeze(value.map(cloneJson));
+    const result = {};
+    for (const [key, entry] of Object.entries(value))
+        result[key] = cloneJson(entry);
+    return Object.freeze(result);
+}
+function groupKey(coordinates) {
+    const encoded = Object.entries(coordinates)
+        .sort(([left], [right]) => compareCanonicalCodeUnits(left, right))
+        .map(([key, value]) => Object.freeze([key, value]));
+    return canonicalIdentity("row", encoded);
+}
+/** Locale-independent ordering for all Analysis identities and closed output. */
+function compareCanonicalCodeUnits(left, right) {
+    if (left === right)
+        return 0;
+    return left < right ? -1 : 1;
+}
+/**
+ * Canonical identities retain their complete normalized input.  They are not
+ * bounded hashes, so distinct coordinates cannot collapse through a digest
+ * collision.
+ */
+function canonicalIdentity(namespace, value) {
+    const encoded = JSON.stringify(value);
+    if (encoded === undefined)
+        throw new Error("Analysis identity input must be JSON-serializable");
+    return `${namespace}-v1:${encoded}`;
+}
+function finiteNumber(value) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        throw new Error("reduction expected a finite number");
+    return value;
+}
+function booleanValue(value) {
+    if (typeof value !== "boolean")
+        throw new Error("ratio reduction expected a boolean");
+    return value;
+}
+function isDimensionValue(value) {
+    return value === null || typeof value === "string" || typeof value === "boolean" ||
+        (typeof value === "number" && Number.isFinite(value));
+}
+function isPlainObject(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function isDimension(value) {
+    return typeof value === "object" && value !== null && value.kind === "dimension";
+}
+function isMeasure(value) {
+    return typeof value === "object" && value !== null && value.kind === "measure";
+}
+function samePopulationMembers(left, right) {
+    return left === right || left.members === right.members;
+}
+function measureStateFor(measure) {
+    return (0, definitions_ts_1.measureState)(measure);
+}
+function requestError(reason) {
+    return Object.freeze({ code: "analysis-request-invalid", reason });
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : "an unknown definition error occurred";
+}
+//# sourceMappingURL=api.cjs.map