@segmentstream/ontology 0.0.0-stage → 0.92.1

package/dist/me.d.ts

@@ -0,0 +1,46 @@
+import { Schema } from "effect";
+/**
+ * `me`, the caller, in the `where` of a scoped role permission. `me` alone is the id of the caller's
+ * `user` record and is compared with `eq` or `ne` (a bare `owner: me` means `eq`).
+ * `me.<relationship>.<relationship>…` is the set of ids a path of relationship names reaches from the
+ * built-in `User`, inverse names first, and is compared with `in`:
+ *
+ * ```ts
+ * { owner: me }
+ * { division: { in: me.staffMember.division } }
+ * ```
+ *
+ * Paths are untyped, since the inverse names live on the other entities; `check` validates them. On
+ * the wire `me` is `{ "$me": [] }` and a path `{ "$me": ["staff_member", "division"] }`, with
+ * snake_case relationship names.
+ */
+export declare const MeTypeId: unique symbol;
+/** `me` or a path from it, as authored. Every string property is one more hop. */
+export interface MeReference {
+    /** The hops from the caller's `user` record, as authored: none for `me` itself. */
+    readonly [MeTypeId]: ReadonlyArray<string>;
+    readonly [relationship: string]: MeReference;
+}
+/** The key of the wire form, `{ "$me": [...] }`. */
+export declare const ME_KEY = "$me";
+/** The most hops a path takes from the caller's `user` record. */
+export declare const MAX_ME_HOPS = 3;
+/** `me` or a path on the wire: `{ "$me": [] }`, `{ "$me": ["staff_member", "division"] }`. */
+export declare const MeMarker: Schema.Struct<{
+    readonly $me: Schema.$Array<Schema.String>;
+}>;
+export type MeMarker = typeof MeMarker.Type;
+/** The caller. `me.staffMember.division` is the set of divisions of the caller's staff member rows. */
+export declare const me: MeReference;
+/** Whether a value is `me` or a path from it, as authored. */
+export declare function isMe(value: unknown): value is MeReference;
+/** Whether a value is the wire form of `me` or of a path: an object whose only key is `$me`. */
+export declare function isMeMarker(value: unknown): value is MeMarker;
+/**
+ * The hops of `me` or of a path, as the value holds them: authored names for an authored
+ * reference, wire names for a wire marker. An empty list is `me` itself; `undefined` means the
+ * value is neither.
+ */
+export declare function mePathOf(value: unknown): ReadonlyArray<string> | undefined;
+/** The wire form of `me` or of a path, from its hops or an authored reference. */
+export declare function meToWire(value: MeReference | ReadonlyArray<string>): MeMarker;

package/dist/me.js

@@ -0,0 +1,109 @@
+import { Schema } from "effect";
+import { nameToWire } from "./authoring-names.js";
+/**
+ * `me`, the caller, in the `where` of a scoped role permission. `me` alone is the id of the caller's
+ * `user` record and is compared with `eq` or `ne` (a bare `owner: me` means `eq`).
+ * `me.<relationship>.<relationship>…` is the set of ids a path of relationship names reaches from the
+ * built-in `User`, inverse names first, and is compared with `in`:
+ *
+ * ```ts
+ * { owner: me }
+ * { division: { in: me.staffMember.division } }
+ * ```
+ *
+ * Paths are untyped, since the inverse names live on the other entities; `check` validates them. On
+ * the wire `me` is `{ "$me": [] }` and a path `{ "$me": ["staff_member", "division"] }`, with
+ * snake_case relationship names.
+ */
+export const MeTypeId = Symbol.for("@segmentstream/ontology/Me");
+/** The key of the wire form, `{ "$me": [...] }`. */
+export const ME_KEY = "$me";
+/** The most hops a path takes from the caller's `user` record. */
+export const MAX_ME_HOPS = 3;
+/** `me` or a path on the wire: `{ "$me": [] }`, `{ "$me": ["staff_member", "division"] }`. */
+export const MeMarker = Schema.Struct({ [ME_KEY]: Schema.Array(Schema.String) }).annotate({
+    identifier: "MeMarker",
+    description: "The caller: an empty list is the id of the caller's user record; relationship names walk from it " +
+        "to the set of ids they reach.",
+});
+/**
+ * Keys a path never takes as a hop, so that runtimes, serializers and test matchers that probe
+ * objects for them find nothing: `then` would make `me` look like a promise, `toJSON` writes the
+ * wire form.
+ */
+const NOT_HOPS = new Set([
+    "then",
+    "toJSON",
+    "toString",
+    "toLocaleString",
+    "valueOf",
+    "constructor",
+    "hasOwnProperty",
+    "isPrototypeOf",
+    "propertyIsEnumerable",
+    "asymmetricMatch",
+    "$$typeof",
+    "nodeType",
+    "tagName",
+    "__proto__",
+]);
+/** `JSON.stringify(me.staffMember)` writes the wire form. */
+function toJSON() {
+    return meToWire(this);
+}
+function reference(hops) {
+    const target = { [MeTypeId]: Object.freeze([...hops]) };
+    Object.defineProperty(target, "toJSON", { value: toJSON, enumerable: false });
+    Object.freeze(target);
+    return new Proxy(target, {
+        get(object, key, receiver) {
+            if (typeof key === "symbol" || NOT_HOPS.has(key) || key in object) {
+                return Reflect.get(object, key, receiver);
+            }
+            return reference([...hops, key]);
+        },
+        has(object, key) {
+            return key in object;
+        },
+        set() {
+            return false;
+        },
+    });
+}
+/** The caller. `me.staffMember.division` is the set of divisions of the caller's staff member rows. */
+export const me = reference([]);
+/** Whether a value is `me` or a path from it, as authored. */
+export function isMe(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        MeTypeId in value &&
+        Array.isArray(value[MeTypeId]));
+}
+/** Whether a value is the wire form of `me` or of a path: an object whose only key is `$me`. */
+export function isMeMarker(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value) || isMe(value)) {
+        return false;
+    }
+    const keys = Object.keys(value);
+    const hops = value[ME_KEY];
+    return (keys.length === 1 &&
+        keys[0] === ME_KEY &&
+        Array.isArray(hops) &&
+        hops.every((hop) => typeof hop === "string"));
+}
+/**
+ * The hops of `me` or of a path, as the value holds them: authored names for an authored
+ * reference, wire names for a wire marker. An empty list is `me` itself; `undefined` means the
+ * value is neither.
+ */
+export function mePathOf(value) {
+    if (isMe(value)) {
+        return value[MeTypeId];
+    }
+    return isMeMarker(value) ? value[ME_KEY] : undefined;
+}
+/** The wire form of `me` or of a path, from its hops or an authored reference. */
+export function meToWire(value) {
+    const hops = isMe(value) ? value[MeTypeId] : value;
+    return { [ME_KEY]: hops.map(nameToWire) };
+}

package/dist/metric-filters.d.ts

@@ -0,0 +1,48 @@
+/**
+ * The filter operators of metric queries and the values each takes, shared by the service's request
+ * schemas and `check`'s metric conditions (docs/ontology-aggregates-release-2-spec.md, "Filters").
+ * The rules and messages are SegmentStream's own (backend-next's `semantics/core/predicates.ts`), so
+ * the SDK, the service and the platform refuse alike.
+ */
+/** A filter value: a literal. */
+export type MetricQueryValue = string | number | boolean;
+/** The operators of a model-level metric query's filters. */
+export declare const METRIC_QUERY_FILTER_OPERATORS: readonly ["equals", "in", "isNull", "isNotNull", "between", "notEquals", "notIn", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "inPeriod"];
+/**
+ * The operators of the per-entity shorthand, which bounds dates with `dateRange` instead of
+ * `between` and `inPeriod`.
+ */
+export declare const ENTITY_METRIC_QUERY_FILTER_OPERATORS: readonly ["equals", "in", "isNull", "isNotNull", "notEquals", "notIn", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith"];
+/**
+ * The operators of a metric condition: a model-level filter's, except `inPeriod`, whose dates would
+ * move with the day a request runs.
+ */
+export declare const METRIC_CONDITION_OPERATORS: readonly ["equals", "in", "notEquals", "notIn", "isNull", "isNotNull", "between", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith"];
+export type MetricConditionOperator = (typeof METRIC_CONDITION_OPERATORS)[number];
+/** The periods `inPeriod` takes without a count. Weeks start on Monday. */
+export declare const METRIC_QUERY_PERIODS: readonly ["today", "yesterday", "this week", "this month", "this quarter", "this year", "this week to date", "this month to date", "this quarter to date", "this year to date", "last week", "last month", "last quarter", "last year"];
+/**
+ * The units of `last N <unit>`, N at least 1: `last N days` ends yesterday; the others are the N
+ * whole units before the current one.
+ */
+export declare const METRIC_QUERY_PERIOD_UNITS: readonly ["days", "weeks", "months", "quarters", "years"];
+/** The most values `in` and `notIn` take. */
+export declare const MAXIMUM_FILTER_VALUES = 100;
+/** An operator and the values given to it, before they are known to suit each other. */
+export interface FilterValues {
+    readonly operator: string;
+    readonly value?: unknown;
+    readonly values?: ReadonlyArray<unknown>;
+}
+/** Why an operator does not take the values given, or `undefined` when it does. */
+export declare function filterValuesIssue(filter: FilterValues): string | undefined;
+/** How SegmentStream compares a dimension's values. */
+export type DimensionType = "string" | "decimal" | "boolean" | "date" | "timestamp";
+/** The dimension type of a property type, or `undefined` for JSON and files, which are none. */
+export declare function dimensionTypeOf(propertyType: string): DimensionType | undefined;
+/**
+ * Why a filter's values do not suit its dimension's type, or `undefined` when they do: the operator
+ * must apply to the type and every value must match it. Their count is {@link filterValuesIssue}'s
+ * to check first. `inPeriod` values are periods, which SegmentStream resolves.
+ */
+export declare function filterTypeIssue(filter: FilterValues, type: DimensionType): string | undefined;

package/dist/metric-filters.js

@@ -0,0 +1,252 @@
+/**
+ * The filter operators of metric queries and the values each takes, shared by the service's request
+ * schemas and `check`'s metric conditions (docs/ontology-aggregates-release-2-spec.md, "Filters").
+ * The rules and messages are SegmentStream's own (backend-next's `semantics/core/predicates.ts`), so
+ * the SDK, the service and the platform refuse alike.
+ */
+/** The operators of a model-level metric query's filters. */
+export const METRIC_QUERY_FILTER_OPERATORS = [
+    "equals",
+    "in",
+    "isNull",
+    "isNotNull",
+    "between",
+    "notEquals",
+    "notIn",
+    "gt",
+    "gte",
+    "lt",
+    "lte",
+    "contains",
+    "startsWith",
+    "endsWith",
+    "inPeriod",
+];
+/**
+ * The operators of the per-entity shorthand, which bounds dates with `dateRange` instead of
+ * `between` and `inPeriod`.
+ */
+export const ENTITY_METRIC_QUERY_FILTER_OPERATORS = [
+    "equals",
+    "in",
+    "isNull",
+    "isNotNull",
+    "notEquals",
+    "notIn",
+    "gt",
+    "gte",
+    "lt",
+    "lte",
+    "contains",
+    "startsWith",
+    "endsWith",
+];
+/**
+ * The operators of a metric condition: a model-level filter's, except `inPeriod`, whose dates would
+ * move with the day a request runs.
+ */
+export const METRIC_CONDITION_OPERATORS = [
+    "equals",
+    "in",
+    "notEquals",
+    "notIn",
+    "isNull",
+    "isNotNull",
+    "between",
+    "gt",
+    "gte",
+    "lt",
+    "lte",
+    "contains",
+    "startsWith",
+    "endsWith",
+];
+/** The periods `inPeriod` takes without a count. Weeks start on Monday. */
+export const METRIC_QUERY_PERIODS = [
+    "today",
+    "yesterday",
+    "this week",
+    "this month",
+    "this quarter",
+    "this year",
+    "this week to date",
+    "this month to date",
+    "this quarter to date",
+    "this year to date",
+    "last week",
+    "last month",
+    "last quarter",
+    "last year",
+];
+/**
+ * The units of `last N <unit>`, N at least 1: `last N days` ends yesterday; the others are the N
+ * whole units before the current one.
+ */
+export const METRIC_QUERY_PERIOD_UNITS = ["days", "weeks", "months", "quarters", "years"];
+/** The most values `in` and `notIn` take. */
+export const MAXIMUM_FILTER_VALUES = 100;
+const COMPARISONS = new Set(["gt", "gte", "lt", "lte"]);
+const TEXT_OPERATORS = new Set(["contains", "startsWith", "endsWith"]);
+function oneValue({ value, values }) {
+    return value !== undefined && values === undefined;
+}
+function someValues({ value, values }) {
+    return (value === undefined &&
+        values !== undefined &&
+        values.length > 0 &&
+        values.length <= MAXIMUM_FILTER_VALUES);
+}
+/** Why an operator does not take the values given, or `undefined` when it does. */
+export function filterValuesIssue(filter) {
+    const { operator, value, values } = filter;
+    if (COMPARISONS.has(operator)) {
+        return oneValue(filter) ? undefined : "Comparison filters require one value.";
+    }
+    if (TEXT_OPERATORS.has(operator)) {
+        return oneValue(filter) && typeof value === "string" && value !== ""
+            ? undefined
+            : "Text filters require one non-empty string.";
+    }
+    switch (operator) {
+        case "equals":
+        case "notEquals":
+            return oneValue(filter) ? undefined : "Equality filters require one value.";
+        case "in":
+            return someValues(filter)
+                ? undefined
+                : "Membership filters require between 1 and 100 values.";
+        case "notIn":
+            return someValues(filter) ? undefined : "notIn requires between 1 and 100 values.";
+        case "between":
+            return value === undefined && values?.length === 2
+                ? undefined
+                : "between needs two values in order.";
+        case "inPeriod":
+            // Whether the value is a period is SegmentStream's to say: it resolves it.
+            return oneValue(filter) ? undefined : "inPeriod filters require one period.";
+        case "isNull":
+        case "isNotNull":
+            return value === undefined && values === undefined
+                ? undefined
+                : "Null filters do not accept values.";
+        default:
+            return undefined;
+    }
+}
+const DIMENSION_TYPES = {
+    text: "string",
+    email: "string",
+    url: "string",
+    select: "string",
+    integer: "decimal",
+    number: "decimal",
+    boolean: "boolean",
+    date: "date",
+    timestamp: "timestamp",
+};
+/** The dimension type of a property type, or `undefined` for JSON and files, which are none. */
+export function dimensionTypeOf(propertyType) {
+    return Object.hasOwn(DIMENSION_TYPES, propertyType) ? DIMENSION_TYPES[propertyType] : undefined;
+}
+function isDate(value) {
+    return (typeof value === "string" &&
+        /^\d{4}-\d{2}-\d{2}$/.test(value) &&
+        !Number.isNaN(Date.parse(value)) &&
+        new Date(value).toISOString().slice(0, 10) === value);
+}
+/** Whether a value is a literal of the type, as SegmentStream reads filter values. */
+function matches(value, type) {
+    if (type === "boolean") {
+        return typeof value === "boolean";
+    }
+    if (type === "decimal") {
+        return ((typeof value === "number" || typeof value === "string") &&
+            String(value).length <= 100 &&
+            /^[-+]?(?:\d+\.?\d*|\.\d+)$/.test(String(value)) &&
+            Number.isFinite(Number(value)));
+    }
+    if (typeof value !== "string" || value.length > 2048) {
+        return false;
+    }
+    if (type === "timestamp") {
+        return (/^\d{4}-\d{2}-\d{2}T/.test(value) &&
+            /(?:Z|[+-]\d{2}:\d{2})$/.test(value) &&
+            Number.isFinite(Date.parse(value)));
+    }
+    return type !== "date" || isDate(value);
+}
+/** Bounds of a timestamp may be dates, which cover whole days; then they are compared as dates. */
+function boundType(bounds, type) {
+    return type === "timestamp" && bounds.every(isDate) ? "date" : type;
+}
+/** Compares two decimal literals exactly, as their digits say, however many there are. */
+function compareDecimals(left, right) {
+    const parse = (value) => {
+        const negative = value.startsWith("-");
+        const [whole = "", fraction = ""] = value.replace(/^[-+]/, "").split(".");
+        const digits = whole.replace(/^0+/, "");
+        const decimals = fraction.replace(/0+$/, "");
+        const zero = digits === "" && decimals === "";
+        return { negative: negative && !zero, digits, decimals };
+    };
+    const a = parse(left);
+    const b = parse(right);
+    if (a.negative !== b.negative) {
+        return a.negative ? -1 : 1;
+    }
+    const width = Math.max(a.decimals.length, b.decimals.length);
+    const magnitude = (value) => value.digits.padStart(Math.max(a.digits.length, b.digits.length), "0") +
+        value.decimals.padEnd(width, "0");
+    // Equal-length digit strings order as their values do.
+    const [first, second] = [magnitude(a), magnitude(b)];
+    if (first === second) {
+        return 0;
+    }
+    const sign = first < second ? -1 : 1;
+    return a.negative ? -sign : sign;
+}
+function inOrder(from, to, type) {
+    if (type === "decimal") {
+        return compareDecimals(String(from), String(to)) <= 0;
+    }
+    if (type === "timestamp") {
+        return Date.parse(String(from)) <= Date.parse(String(to));
+    }
+    return String(from) <= String(to);
+}
+const MISMATCH = "Filter value does not match its dimension type.";
+const ORDERED_TYPES = new Set(["date", "timestamp", "decimal"]);
+/**
+ * Why a filter's values do not suit its dimension's type, or `undefined` when they do: the operator
+ * must apply to the type and every value must match it. Their count is {@link filterValuesIssue}'s
+ * to check first. `inPeriod` values are periods, which SegmentStream resolves.
+ */
+export function filterTypeIssue(filter, type) {
+    const { operator, value, values = [] } = filter;
+    const given = value === undefined ? values : [value];
+    if (operator === "between") {
+        const [from, to] = given;
+        const bounds = boundType([from, to], type);
+        if (!ORDERED_TYPES.has(type)) {
+            return "between filters date, timestamp and number dimensions.";
+        }
+        if (!matches(from, bounds) || !matches(to, bounds)) {
+            return MISMATCH;
+        }
+        return inOrder(from, to, bounds) ? undefined : "between needs two values in order.";
+    }
+    if (operator === "inPeriod") {
+        return type === "date" || type === "timestamp"
+            ? undefined
+            : "inPeriod filters date and timestamp dimensions.";
+    }
+    if (COMPARISONS.has(operator) && !ORDERED_TYPES.has(type)) {
+        return `${operator} filters date, timestamp and number dimensions.`;
+    }
+    if (TEXT_OPERATORS.has(operator) && type !== "string") {
+        return `${operator} filters text dimensions.`;
+    }
+    // A comparison bounds a timestamp by a date or by an exact instant, as `between` does.
+    const valueType = COMPARISONS.has(operator) ? boundType(given, type) : type;
+    return given.every((candidate) => matches(candidate, valueType)) ? undefined : MISMATCH;
+}

package/dist/metric-routes.d.ts

@@ -0,0 +1,132 @@
+import type { ModelMetricManifest, OntologyManifest } from "./manifest.js";
+/**
+ * The names of a model-level metric query, as `/api/ontology/query_metrics` and the platform's
+ * `POST …/metrics/query` receive them: wire snake_case, `entity.member`.
+ */
+export interface MetricQueryNames {
+    /** `entity.metric`, or the bare name of a metric of the model. */
+    readonly metrics: readonly string[];
+    /** An identity, `entity.property`, or a route, `rootEntity.relationship[.relationship].property`. */
+    readonly dimensions?: readonly string[];
+    /** The dimension name of every filter, in the same forms as dimensions. */
+    readonly filters?: readonly string[];
+    /** A requested dimension, by its requested name or its identity. */
+    readonly granularityOf?: string;
+}
+/** How one metric entity reads every requested name. Paths are relative to the entity. */
+export interface EntityRoutes {
+    readonly entity: string;
+    /**
+     * The metrics the entity computes, without the entity prefix, each once: its requested metrics
+     * in request order, then the hidden inputs of the requested model metrics that read it, in their
+     * declaration order.
+     */
+    readonly metrics: readonly string[];
+    /**
+     * Every requested dimension, in request order: `brand`, `product.brand`, `product.region.name`.
+     * A dimension that a requested model metric aligns reads the entity's own member of the group;
+     * `null` when the member is `null`, so the entity is broadcast across the dimension's values.
+     */
+    readonly dimensions: readonly {
+        readonly identity: string;
+        readonly path: string | null;
+    }[];
+    /** The filters that apply to the entity, by their requested dimension name. */
+    readonly filters: readonly {
+        readonly name: string;
+        readonly path: string;
+    }[];
+    /**
+     * The requested filter names that do not apply to the entity: it cannot reach them, or an
+     * alignment says it has no counterpart.
+     */
+    readonly unappliedFilters: readonly string[];
+    /** The path of the bucketed dimension, when the request names one and the entity groups by it. */
+    readonly granularityOf?: string;
+}
+/** A requested metric of the model: the entity metrics it reads, and their entities. */
+export interface ModelMetricRoute {
+    readonly name: string;
+    /** `entity.metric`, in declaration order. */
+    readonly inputs: readonly string[];
+    /** The entities of the inputs, each once, in the order of the inputs. */
+    readonly entities: readonly string[];
+}
+export type MetricRoutes = {
+    readonly ok: true;
+    /**
+     * The metric entities, in the order their first metric was requested: an entity metric's
+     * entity, or the entities of a model metric's inputs.
+     */
+    readonly entities: readonly EntityRoutes[];
+    /**
+     * Every entity the request reads, the entities of model metrics' inputs included, sorted:
+     * each needs `<entity>:read`.
+     */
+    readonly touched: readonly string[];
+    /** The requested model metrics, in request order. */
+    readonly model: readonly ModelMetricRoute[];
+} | {
+    readonly ok: false;
+    readonly reason: string;
+};
+/** A route follows at most this many to-one relationships. */
+export declare const MAXIMUM_HOPS = 2;
+/**
+ * The JSON Schema pattern of a metric query's name: `entity.member`, or a route of at most
+ * {@link MAXIMUM_HOPS} relationships from a metric entity, in snake_case segments.
+ */
+export declare const METRIC_QUERY_NAME_PATTERN = "^[a-z][a-z0-9_]*(?:\\.[a-z][a-z0-9_]*){1,3}$";
+/** To-one relationships followed from an entity, and every entity visited, both ends included. */
+export interface MetricRoute {
+    readonly relationships: readonly string[];
+    readonly entities: readonly string[];
+}
+/** The built-in User is never replicated, so no route passes through it or ends at it. */
+export declare function isBuiltInUser(entity: string): boolean;
+export declare function hopLimitMessage(): string;
+export declare function userPathMessage(): string;
+export declare function unknownRelationshipMessage(input: {
+    readonly entity: string;
+    readonly relationship: string;
+}): string;
+/** A `rel.many`, or an inverse, which is to-many from the side that names it. */
+export declare function toManySegmentMessage(input: {
+    readonly entity: string;
+    readonly relationship: string;
+}): string;
+export declare function unknownPropertyMessage(input: {
+    readonly entity: string;
+    readonly property: string;
+}): string;
+/** A bare metric name that is not a metric of the model. */
+export declare function unknownModelMetricMessage(name: string): string;
+/** A filter that applies to some entities a model metric reads and cannot reach another. */
+export declare function partialFilterMessage(input: {
+    readonly filter: string;
+    readonly entity: string;
+    readonly metric: string;
+}): string;
+/**
+ * Every entity one entity reaches, with the shortest routes there, in the order they are first
+ * reached. Routes follow one to {@link MAXIMUM_HOPS} declared `rel.one`s, never inverses, never
+ * through User, and never visit an entity twice; several routes to one target are listed in
+ * declaration order. These are the routes metric query resolution weighs.
+ */
+export declare function shortestRoutesFrom(manifest: OntologyManifest, from: string): ReadonlyMap<string, readonly MetricRoute[]>;
+/** The shortest routes from one entity to another, under {@link shortestRoutesFrom}'s rules. */
+export declare function shortestRoutes(manifest: OntologyManifest, input: {
+    readonly from: string;
+    readonly to: string;
+}): readonly MetricRoute[];
+/** The entities a model metric reads, each once, in the order of its inputs. */
+export declare function inputEntities(metric: Pick<ModelMetricManifest, "inputs">): readonly string[];
+/**
+ * Resolves the names of a model-level metric query against a manifest
+ * (docs/ontology-aggregates-spec.md, "Resolution"). It is the one place names and routes resolve: backend-next plans each metric
+ * entity from it, and the ontology service checks `<entity>:read` on every entity it touches.
+ *
+ * Pure: it reads only the manifest. It does not check partitions, currency, replication or metric
+ * operators, nor add scope parents, which the planner adds along the same relative path.
+ */
+export declare function resolveMetricRoutes(manifest: OntologyManifest, names: MetricQueryNames): MetricRoutes;