@segmentstream-cloud/ontology 0.21.0 → 0.23.0

package/README.md

@@ -11,7 +11,7 @@ action and is kept in history.
 TypeScript definitions, handler records and SDK calls use camelCase: `jobTitle`,
 `assignedOwnerId`, `createdAt`, and `changeStatus`. The SDK converts ontology names,
 select identifiers and declared action input fields to snake_case for the generated
-REST API, version 7 manifest and storage. TypeScript helpers and options stay
+REST API, version 8 manifest and storage. TypeScript helpers and options stay
 camelCase. JSON property contents, provider payloads, opaque action results and
 historical change names remain data and are preserved. `formatManifest` serializes
 the canonical wire contract shared by REST, storage and future transports.
@@ -28,6 +28,31 @@ one Effect version.
 `ontology/` is a package of its own. The SDK is an ES module, so `ontology/package.json`
 must set `"type": "module"`.
 
+SDK 0.23.0 writes manifest version 8. `defineOntology({ measures })` declares measures of the
+model: arithmetic over measures of entities, `m.ref("acmeSales.ordered")`, and over other
+model measures, `m.ref("planAttainment")`. `align` names the properties that stand for one another
+across the entities a measure reads, or `null` for an entity without a counterpart, such as a
+current snapshot without a date:
+
+```ts
+defineOntology({
+  entities: [AcmeSales, AcmePlans],
+  measures: {
+    planAttainment: m.divide(m.ref("acmeSales.ordered"), m.ref("acmePlans.plannedUnits"), {
+      align: [{ acmeSales: "orderDate", acmePlans: "month" }],
+      unit: "ratio",
+      description: "Ordered units over planned units for the same months.",
+    }),
+  },
+});
+```
+
+Aggregate requests name a measure of the model by its bare name, `plan_attainment`, beside
+`entity.measure`; a filter must reach every entity it reads unless its alignment says the entity has
+no counterpart, and reading it requires reading each of those entities. `check` refuses aggregates
+inside a measure of the model, unknown references, cycles and alignments that do not name every
+entity once with properties of one type. Entity measures take no `align`.
+
 SDK 0.17.0 writes manifest version 7. It adds `m.avg`, `m.min` and `m.max`; a `where` option on
 every aggregate, so that a measure reads only the rows its conditions accept (`m.sum("amount",
 { where: [{ property: "status", operator: "equals", value: "won" }], description })`); and
@@ -72,7 +97,7 @@ SDK 0.13.0 also serves aggregates. Upgrade notes:
 - Under `signIn: { policy: "open" }`, anyone who signs in holds `member`, so `check` refuses a
   `member` whose wildcard (`*:read`, the default, or `*:*`) would let strangers read
   warehouse-backed entities through aggregates. Grant those to `member` by name
-  (`trendtoys_sales:read`), or keep the `invited` policy.
+  (`acme_sales:read`), or keep the `invited` policy.
 
 See [ontology aggregates](https://github.com/segmentstream/segmentstream/blob/main/docs/ontology-aggregates.md)
 and [ontology analytics](https://github.com/segmentstream/segmentstream/blob/main/docs/ontology-aggregates-spec.md).

package/dist/aggregate-routes.d.ts

@@ -1,10 +1,10 @@
-import type { OntologyManifest } from "./manifest.js";
+import type { ModelMeasureManifest, OntologyManifest } from "./manifest.js";
 /**
  * The names of a model-level aggregate request, as `/api/ontology/aggregate` and the platform's
  * `POST …/aggregate` receive them: wire snake_case, `entity.member`.
  */
 export interface AggregateNames {
-    /** `entity.measure`. */
+    /** `entity.measure`, or the bare name of a measure of the model. */
     readonly measures: readonly string[];
     /** An identity, `entity.property`, or a route, `rootEntity.relationship[.relationship].property`. */
     readonly dimensions?: readonly string[];
@@ -16,29 +16,56 @@ export interface AggregateNames {
 /** How one measure entity reads every requested name. Paths are relative to the entity. */
 export interface EntityRoutes {
     readonly entity: string;
-    /** The entity's requested measures, without the entity prefix, in request order. */
+    /**
+     * The measures the entity computes, without the entity prefix, each once: its requested measures
+     * in request order, then the hidden inputs of the requested model measures that read it, in their
+     * declaration order.
+     */
     readonly measures: readonly string[];
-    /** Every requested dimension, in request order: `brand`, `product.brand`, `product.region.name`. */
+    /**
+     * Every requested dimension, in request order: `brand`, `product.brand`, `product.region.name`.
+     * A dimension that a requested model measure 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;
+        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. */
+    /**
+     * 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. */
+    /** The path of the bucketed dimension, when the request names one and the entity groups by it. */
     readonly granularityOf?: string;
 }
+/** A requested measure of the model: the entity measures it reads, and their entities. */
+export interface ModelMeasureRoute {
+    readonly name: string;
+    /** `entity.measure`, 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 AggregateRoutes = {
     readonly ok: true;
-    /** The measure entities, in the order their first measure was requested. */
+    /**
+     * The measure entities, in the order their first measure was requested: an entity measure's
+     * entity, or the entities of a model measure's inputs.
+     */
     readonly entities: readonly EntityRoutes[];
-    /** Every entity the request reads, sorted: each needs `<entity>:read`. */
+    /**
+     * Every entity the request reads, the entities of model measures' inputs included, sorted:
+     * each needs `<entity>:read`.
+     */
     readonly touched: readonly string[];
+    /** The requested model measures, in request order. */
+    readonly model: readonly ModelMeasureRoute[];
 } | {
     readonly ok: false;
     readonly reason: string;
@@ -72,6 +99,14 @@ export declare function unknownPropertyMessage(input: {
     readonly entity: string;
     readonly property: string;
 }): string;
+/** A bare measure name that is not a measure of the model. */
+export declare function unknownModelMeasureMessage(name: string): string;
+/** A filter that applies to some entities a model measure reads and cannot reach another. */
+export declare function partialFilterMessage(input: {
+    readonly filter: string;
+    readonly entity: string;
+    readonly measure: 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
@@ -84,6 +119,8 @@ export declare function shortestRoutes(manifest: OntologyManifest, input: {
     readonly from: string;
     readonly to: string;
 }): readonly AggregateRoute[];
+/** The entities a model measure reads, each once, in the order of its inputs. */
+export declare function inputEntities(measure: Pick<ModelMeasureManifest, "inputs">): readonly string[];
 /**
  * Resolves the names of a model-level aggregate against a manifest (docs/ontology-aggregates-spec.md,
  * "Resolution"). It is the one place names and routes resolve: backend-next plans each measure

package/dist/aggregate-routes.js

@@ -29,6 +29,15 @@ export function toManySegmentMessage(input) {
 export function unknownPropertyMessage(input) {
     return `${input.entity} has no property ${input.property}.`;
 }
+/** A bare measure name that is not a measure of the model. */
+export function unknownModelMeasureMessage(name) {
+    return `The ontology has no measure named ${name}.`;
+}
+/** A filter that applies to some entities a model measure reads and cannot reach another. */
+export function partialFilterMessage(input) {
+    return (`${input.filter} does not apply to ${input.entity}, which ${input.measure} reads; align the ` +
+        "properties in the measure, or request its inputs instead.");
+}
 function entitiesByName(manifest) {
     return new Map(manifest.entities.map((entity) => [entity.name, entity]));
 }
@@ -86,16 +95,25 @@ class Refusal extends Error {
 function refuse(reason) {
     throw new Refusal(reason);
 }
-/** The ontology's entities by name, and the shortest routes from each measure entity. */
+/**
+ * The ontology's entities and measures of the model by name, and the shortest routes from each
+ * measure entity.
+ */
 class RouteCatalog {
     entities;
+    measures;
     routes = new Map();
     constructor(manifest) {
         this.entities = entitiesByName(manifest);
+        this.measures = new Map((manifest.measures ?? []).map((measure) => [measure.name, measure]));
     }
     entity(name) {
         return this.entities.get(name) ?? refuse(`${name} is not an entity of this ontology.`);
     }
+    /** A measure of the model; a manifest before version 8 declares none. */
+    modelMeasure(name) {
+        return this.measures.get(name) ?? refuse(unknownModelMeasureMessage(name));
+    }
     /** Declared properties, and the `id` of a stored entity, which its replication view carries. */
     hasProperty(entity, property) {
         const stored = entity.source === undefined && !entity.builtIn;
@@ -113,10 +131,23 @@ class RouteCatalog {
         return reached.get(to) ?? [];
     }
 }
-/** The requested measures, grouped by entity in the order each entity's first measure appears. */
-function measureEntities(input) {
+/**
+ * The requested measures, by entity. A bare name is a measure of the model, which reads the
+ * entities of its inputs; `entity.measure` is a measure of the entity.
+ */
+function requestedMeasures(input) {
     const { catalog, measures } = input;
-    const groups = new Map();
+    const entities = new Map();
+    const model = [];
+    const measureEntity = (name) => {
+        const existing = entities.get(name);
+        if (existing !== undefined) {
+            return existing;
+        }
+        const created = { entity: catalog.entity(name).name, requested: [], inputs: [], readers: [] };
+        entities.set(name, created);
+        return created;
+    };
     if (measures.length === 0) {
         refuse("Request at least one measure.");
     }
@@ -125,6 +156,18 @@ function measureEntities(input) {
         if (measures.indexOf(name) !== index) {
             refuse(`${name} is requested twice.`);
         }
+        if (segments.length === 1 && name.length > 0) {
+            const measure = catalog.modelMeasure(name);
+            model.push(measure);
+            for (const qualified of measure.inputs) {
+                const owner = measureEntity(qualified.slice(0, qualified.indexOf(SEPARATOR)));
+                owner.inputs.push(qualified.slice(qualified.indexOf(SEPARATOR) + 1));
+                if (!owner.readers.includes(measure)) {
+                    owner.readers.push(measure);
+                }
+            }
+            continue;
+        }
         if (segments.length !== 2 || segments.some((segment) => segment.length === 0)) {
             refuse(`${name} is not a measure name; write <entity>.<measure>.`);
         }
@@ -133,9 +176,13 @@ function measureEntities(input) {
         if (!(entity.measures ?? []).some((candidate) => candidate.name === measure)) {
             refuse(`${entityName} has no measure ${measure}.`);
         }
-        groups.set(entityName, [...(groups.get(entityName) ?? []), measure]);
+        measureEntity(entityName).requested.push(measure);
     }
-    return groups;
+    return { entities, model };
+}
+/** The entities a model measure reads, each once, in the order of its inputs. */
+export function inputEntities(measure) {
+    return [...new Set(measure.inputs.map((input) => input.slice(0, input.indexOf(SEPARATOR))))];
 }
 /**
  * Parses an identity, `entity.property`, or a route form, `root.relationship[.relationship].property`,
@@ -217,6 +264,79 @@ function resolveName(input) {
     }
     return { kind: "resolved", route: routes[0] };
 }
+/**
+ * The member of an entity in the group of a model measure's alignment that an identity belongs to:
+ * a property, `null` when the entity has no counterpart, or `undefined` when no group has the
+ * identity.
+ */
+function memberOf(input) {
+    const { measure, entity, identity } = input;
+    const group = measure.align.find((candidate) => Object.entries(candidate).some(([owner, property]) => property !== null && `${owner}${SEPARATOR}${property}` === identity));
+    if (group === undefined || !Object.hasOwn(group, entity)) {
+        return undefined;
+    }
+    return group[entity] ?? null;
+}
+/**
+ * How the requested model measures that read an entity align a requested name: the entity's own
+ * member of the group the name's identity belongs to, `null` when the entity has no counterpart, or
+ * `undefined` when none of them aligns it. Two that align it differently are refused: the entity
+ * computes its inputs once.
+ */
+function alignedMember(input) {
+    const { entity, requested } = input;
+    let aligned;
+    for (const reader of entity.readers) {
+        const member = memberOf({
+            measure: reader,
+            entity: entity.entity,
+            identity: requested.identity,
+        });
+        if (member === undefined) {
+            continue;
+        }
+        if (aligned !== undefined && aligned.member !== member) {
+            refuse(`${requested.identity} is aligned differently by ${aligned.by} and ${reader.name}.`);
+        }
+        aligned ??= { by: reader.name, member };
+    }
+    return aligned?.member;
+}
+function resolveFor(input) {
+    const { catalog, entity, requested } = input;
+    const member = alignedMember({ entity, requested });
+    if (member !== undefined) {
+        return { kind: "aligned", path: member };
+    }
+    return resolveName({ catalog, from: entity.entity, requested });
+}
+/**
+ * Two requested dimensions that are members of one alignment group of a requested model measure
+ * would group each of its entities twice by the same property.
+ */
+function refuseAlignedTwice(input) {
+    const { model, dimensions } = input;
+    for (const measure of model) {
+        for (const group of measure.align) {
+            const members = dimensions.filter(({ identity }) => Object.entries(group).some(([entity, property]) => property !== null && `${entity}${SEPARATOR}${property}` === identity));
+            const [first, second] = members;
+            if (first !== undefined && second !== undefined) {
+                refuse(`${second.identity} is aligned with ${first.identity}; request one of them.`);
+            }
+        }
+    }
+}
+/**
+ * A dimension that a measure entity cannot reach, named after its first requested measure, or after
+ * the first requested model measure that reads it.
+ */
+function unreachableMessage(entity, identity) {
+    const [requested] = entity.requested;
+    if (requested !== undefined) {
+        return `${entity.entity}${SEPARATOR}${requested} cannot reach ${identity}.`;
+    }
+    return `${entity.readers[0]?.name} reads ${entity.entity}, which cannot reach ${identity}.`;
+}
 function ambiguousRoute(input) {
     const { from, requested, routes } = input;
     const count = COUNT_WORDS[routes.length] ?? String(routes.length);
@@ -258,7 +378,8 @@ function resolve(catalog, names) {
     const measureNames = namesOf("measures", names.measures);
     const dimensionNames = namesOf("dimensions", names.dimensions ?? []);
     const filterNames = namesOf("filters", names.filters ?? []);
-    const groups = measureEntities({ catalog, measures: measureNames });
+    const requested = requestedMeasures({ catalog, measures: measureNames });
+    const groups = requested.entities;
     const touched = new Set(groups.keys());
     const dimensions = dimensionNames.map((name) => parseName({ catalog, roots: groups, name }));
     for (const [index, dimension] of dimensions.entries()) {
@@ -266,6 +387,7 @@ function resolve(catalog, names) {
             refuse(`${dimension.identity} is requested twice.`);
         }
     }
+    refuseAlignedTwice({ model: requested.model, dimensions });
     const { granularityOf } = names;
     const bucketed = granularityOf === undefined
         ? undefined
@@ -278,15 +400,17 @@ function resolve(catalog, names) {
         touched.add(filter.target);
         filter.written?.route.entities.forEach((entity) => touched.add(entity));
     }
-    const routed = [...groups].map(([entity, measures]) => {
-        const firstMeasure = `${entity}${SEPARATOR}${measures[0]}`;
+    const routed = [...groups.values()].map((entity) => {
         const dimensionRoutes = dimensions.map((dimension) => {
-            const resolution = resolveName({ catalog, from: entity, requested: dimension });
+            const resolution = resolveFor({ catalog, entity, requested: dimension });
+            if (resolution.kind === "aligned") {
+                return { identity: dimension.identity, path: resolution.path };
+            }
             if (resolution.kind === "unreachable") {
-                refuse(`${firstMeasure} cannot reach ${dimension.identity}.`);
+                refuse(unreachableMessage(entity, dimension.identity));
             }
             if (resolution.kind === "ambiguous") {
-                refuse(ambiguousRoute({ from: entity, requested: dimension, routes: resolution.routes }));
+                refuse(ambiguousRoute({ from: entity.entity, requested: dimension, routes: resolution.routes }));
             }
             resolution.route.entities.forEach((visited) => touched.add(visited));
             return {
@@ -294,39 +418,81 @@ function resolve(catalog, names) {
                 path: pathOf(resolution.route, dimension.property),
             };
         });
-        return { entity, measures, dimensionRoutes };
+        return { entity, dimensionRoutes };
     });
-    const entities = routed.map(({ entity, measures, dimensionRoutes }) => {
+    const reach = new Map();
+    const entities = routed.map(({ entity, dimensionRoutes }) => {
         const applied = [];
         const unappliedFilters = [];
+        const reached = new Map();
         for (const filter of filters) {
-            const resolution = resolveName({ catalog, from: entity, requested: filter });
+            const resolution = resolveFor({ catalog, entity, requested: filter });
+            if (resolution.kind === "aligned") {
+                if (resolution.path === null) {
+                    unappliedFilters.push(filter.name);
+                    reached.set(filter.name, "noCounterpart");
+                }
+                else {
+                    applied.push({ name: filter.name, path: resolution.path });
+                    reached.set(filter.name, "applied");
+                }
+                continue;
+            }
             if (resolution.kind === "ambiguous") {
-                refuse(ambiguousRoute({ from: entity, requested: filter, routes: resolution.routes }));
+                refuse(ambiguousRoute({ from: entity.entity, requested: filter, routes: resolution.routes }));
             }
             if (resolution.kind === "unreachable") {
                 unappliedFilters.push(filter.name);
+                reached.set(filter.name, "unreachable");
                 continue;
             }
             resolution.route.entities.forEach((visited) => touched.add(visited));
             applied.push({ name: filter.name, path: pathOf(resolution.route, filter.property) });
+            reached.set(filter.name, "applied");
         }
+        reach.set(entity.entity, reached);
         const bucketedPath = bucketed === undefined
             ? undefined
             : dimensionRoutes.find((route) => route.identity === bucketed.identity)?.path;
         return {
-            entity,
-            measures,
+            entity: entity.entity,
+            measures: [...new Set([...entity.requested, ...entity.inputs])],
             dimensions: dimensionRoutes,
             filters: applied,
             unappliedFilters,
-            ...(bucketedPath === undefined ? {} : { granularityOf: bucketedPath }),
+            ...(bucketedPath === undefined || bucketedPath === null
+                ? {}
+                : { granularityOf: bucketedPath }),
         };
     });
+    const model = requested.model.map((measure) => ({
+        name: measure.name,
+        inputs: measure.inputs,
+        entities: inputEntities(measure),
+    }));
     for (const filter of filters) {
+        // A model measure's inputs are filtered alike, or the filter is refused: a filtered numerator
+        // over an unfiltered denominator would answer another question. Only the measure's own
+        // alignment may say that an entity it reads has no counterpart.
+        for (const measure of requested.model) {
+            const states = inputEntities(measure).map((entity) => {
+                const state = reach.get(entity)?.get(filter.name);
+                const exempt = state === "noCounterpart" &&
+                    memberOf({ measure, entity, identity: filter.identity }) === null;
+                return { entity, state: state === "noCounterpart" && !exempt ? "unreachable" : state };
+            });
+            const missed = states.find(({ state }) => state === "unreachable");
+            if (missed !== undefined && states.some(({ state }) => state === "applied")) {
+                refuse(partialFilterMessage({
+                    filter: filter.name,
+                    entity: missed.entity,
+                    measure: measure.name,
+                }));
+            }
+        }
         if (entities.every((routes) => routes.unappliedFilters.includes(filter.name))) {
             refuse(`No measure can reach ${filter.name}.`);
         }
     }
-    return { entities, touched: [...touched].sort() };
+    return { entities, touched: [...touched].sort(), model };
 }

package/dist/analyze.d.ts

@@ -7,8 +7,10 @@ import { type PropertyDefinition } from "./property.js";
 import { type AnyRelationship } from "./relationship.js";
 import { type Role } from "./role.js";
 import { type SignInOptions } from "./sign-in.js";
+import type { ModelMeasureManifest } from "./manifest.js";
+import type { ModelMeasures } from "./measure.js";
 /** The input of `defineOntology` and `check`. */
-export interface OntologyConfig<Entities extends ReadonlyArray<AnyEntity> = ReadonlyArray<AnyEntity>> {
+export interface OntologyConfig<Entities extends ReadonlyArray<AnyEntity> = ReadonlyArray<AnyEntity>, Measures extends ModelMeasures = ModelMeasures> {
     /**
      * The app's entities. The built-in `User` and `AgentChat` are always included; listing them is
      * optional.
@@ -28,6 +30,13 @@ export interface OntologyConfig<Entities extends ReadonlyArray<AnyEntity> = Read
      * handle an action lists must be here, and every handle here must be used by an action.
      */
     readonly connections?: ReadonlyArray<AnyConnectionHandle>;
+    /**
+     * Measures of the model, by camelCase name: each combines measures of entities, read with
+     * `m.ref("entity.measure")`, or other model measures, read with `m.ref("name")`, through
+     * `m.add`, `m.subtract`, `m.multiply`, `m.divide` and `m.literal`. `align` names the properties
+     * that stand for one another across the entities it reads.
+     */
+    readonly measures?: Measures;
 }
 /** What every active app user may do, beyond the roles they are given. */
 export interface MemberOptions {
@@ -115,6 +124,8 @@ export interface Analysis {
     readonly signIn: SignInOptions;
     /** The declared connections, in order. */
     readonly connections: ReadonlyArray<ResolvedConnection>;
+    /** The measures of the model that passed `check`, in their manifest form. */
+    readonly measures: ReadonlyArray<ModelMeasureManifest>;
     readonly diagnostics: ReadonlyArray<Diagnostic>;
 }
 /**

package/dist/analyze.js

@@ -15,6 +15,7 @@ import { AgentChat } from "./agent-chat.js";
 import { User } from "./user.js";
 import { authoringToWire } from "./authoring.js";
 import { nameToWire } from "./authoring-names.js";
+import { resolveModelMeasures } from "./model-measures.js";
 const GENERATED_UPSERT = new RegExp(`^${GENERATED_UPSERT_PREFIX}`);
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
@@ -60,12 +61,13 @@ export function analyze(config, options = {}) {
     checkMemberNames(resolved, report);
     checkToolNames(resolved, report);
     checkWarehouseSource(resolved, report);
+    const measures = resolveModelMeasures({ measures: config.measures, entities: resolved, report });
     checkConnectionsUsed(resolved, connections, config.connections ?? [], report);
     if (options.checkPermissions !== false) {
         checkPermissions(resolved, roles, report);
         checkOpenWarehouseReads({ entities: resolved, roles, signIn, report });
     }
-    return { entities: resolved, roles, signIn, connections, diagnostics };
+    return { entities: resolved, roles, signIn, connections, measures, diagnostics };
 }
 /**
  * The operations of a stored entity that become MCP tools, each with the path a problem is reported

package/dist/diagnostics.d.ts

@@ -1,10 +1,10 @@
 import { Schema } from "effect";
-export declare const DIAGNOSTIC_CODES: readonly ["invalid-source", "missing-column", "invalid-column", "invalid-scope", "source-with-actions", "source-with-index", "invalid-measure", "unknown-measure", "circular-measure", "invalid-join", "missing-join", "invalid-entity", "invalid-property", "invalid-relationship", "invalid-actions", "invalid-action", "invalid-action-input", "invalid-role", "invalid-name", "reserved-name", "duplicate-name", "invalid-entity-id", "duplicate-entity-id", "missing-label", "missing-description", "invalid-title", "invalid-options", "invalid-default", "invalid-constraint", "unknown-relationship-target", "inverse-collision", "invalid-on-delete", "invalid-phrase", "invalid-index", "unknown-reference", "invalid-renamed-from", "invalid-guide", "managed-without-effect", "missing-permissions", "invalid-permission", "unknown-permission", "removed-allow", "unreachable-action", "wildcard-permission", "invalid-sign-in", "invalid-connection", "unknown-connection", "unused-connection", "invalid-prepare", "invalid-tool-name"];
+export declare const DIAGNOSTIC_CODES: readonly ["invalid-source", "missing-column", "invalid-column", "invalid-scope", "source-with-actions", "source-with-index", "invalid-measure", "unknown-measure", "circular-measure", "invalid-join", "missing-join", "invalid-entity", "invalid-property", "invalid-relationship", "invalid-actions", "invalid-action", "invalid-action-input", "invalid-role", "invalid-name", "reserved-name", "duplicate-name", "invalid-entity-id", "duplicate-entity-id", "missing-label", "missing-description", "invalid-title", "invalid-options", "invalid-default", "invalid-constraint", "unknown-relationship-target", "inverse-collision", "invalid-on-delete", "invalid-phrase", "invalid-index", "unknown-reference", "invalid-renamed-from", "invalid-guide", "managed-without-effect", "missing-permissions", "invalid-permission", "unknown-permission", "removed-allow", "unreachable-action", "wildcard-permission", "invalid-sign-in", "invalid-connection", "unknown-connection", "unused-connection", "invalid-prepare", "invalid-tool-name", "invalid-alignment", "single-entity-model-measure"];
 export type DiagnosticCode = (typeof DIAGNOSTIC_CODES)[number];
 /** A problem `check` found in an ontology definition. */
 export declare const Diagnostic: Schema.Struct<{
     readonly severity: Schema.Literals<readonly ["error", "warning"]>;
-    readonly code: Schema.Literals<readonly ["invalid-source", "missing-column", "invalid-column", "invalid-scope", "source-with-actions", "source-with-index", "invalid-measure", "unknown-measure", "circular-measure", "invalid-join", "missing-join", "invalid-entity", "invalid-property", "invalid-relationship", "invalid-actions", "invalid-action", "invalid-action-input", "invalid-role", "invalid-name", "reserved-name", "duplicate-name", "invalid-entity-id", "duplicate-entity-id", "missing-label", "missing-description", "invalid-title", "invalid-options", "invalid-default", "invalid-constraint", "unknown-relationship-target", "inverse-collision", "invalid-on-delete", "invalid-phrase", "invalid-index", "unknown-reference", "invalid-renamed-from", "invalid-guide", "managed-without-effect", "missing-permissions", "invalid-permission", "unknown-permission", "removed-allow", "unreachable-action", "wildcard-permission", "invalid-sign-in", "invalid-connection", "unknown-connection", "unused-connection", "invalid-prepare", "invalid-tool-name"]>;
+    readonly code: Schema.Literals<readonly ["invalid-source", "missing-column", "invalid-column", "invalid-scope", "source-with-actions", "source-with-index", "invalid-measure", "unknown-measure", "circular-measure", "invalid-join", "missing-join", "invalid-entity", "invalid-property", "invalid-relationship", "invalid-actions", "invalid-action", "invalid-action-input", "invalid-role", "invalid-name", "reserved-name", "duplicate-name", "invalid-entity-id", "duplicate-entity-id", "missing-label", "missing-description", "invalid-title", "invalid-options", "invalid-default", "invalid-constraint", "unknown-relationship-target", "inverse-collision", "invalid-on-delete", "invalid-phrase", "invalid-index", "unknown-reference", "invalid-renamed-from", "invalid-guide", "managed-without-effect", "missing-permissions", "invalid-permission", "unknown-permission", "removed-allow", "unreachable-action", "wildcard-permission", "invalid-sign-in", "invalid-connection", "unknown-connection", "unused-connection", "invalid-prepare", "invalid-tool-name", "invalid-alignment", "single-entity-model-measure"]>;
     /** Where the problem is, for example `lead.properties.status.options[1]`. */
     readonly path: Schema.String;
     readonly message: Schema.String;
@@ -14,7 +14,7 @@ declare const InvalidOntology_base: Schema.Class<InvalidOntology, Schema.TaggedS
     readonly message: Schema.String;
     readonly diagnostics: Schema.$Array<Schema.Struct<{
         readonly severity: Schema.Literals<readonly ["error", "warning"]>;
-        readonly code: Schema.Literals<readonly ["invalid-source", "missing-column", "invalid-column", "invalid-scope", "source-with-actions", "source-with-index", "invalid-measure", "unknown-measure", "circular-measure", "invalid-join", "missing-join", "invalid-entity", "invalid-property", "invalid-relationship", "invalid-actions", "invalid-action", "invalid-action-input", "invalid-role", "invalid-name", "reserved-name", "duplicate-name", "invalid-entity-id", "duplicate-entity-id", "missing-label", "missing-description", "invalid-title", "invalid-options", "invalid-default", "invalid-constraint", "unknown-relationship-target", "inverse-collision", "invalid-on-delete", "invalid-phrase", "invalid-index", "unknown-reference", "invalid-renamed-from", "invalid-guide", "managed-without-effect", "missing-permissions", "invalid-permission", "unknown-permission", "removed-allow", "unreachable-action", "wildcard-permission", "invalid-sign-in", "invalid-connection", "unknown-connection", "unused-connection", "invalid-prepare", "invalid-tool-name"]>;
+        readonly code: Schema.Literals<readonly ["invalid-source", "missing-column", "invalid-column", "invalid-scope", "source-with-actions", "source-with-index", "invalid-measure", "unknown-measure", "circular-measure", "invalid-join", "missing-join", "invalid-entity", "invalid-property", "invalid-relationship", "invalid-actions", "invalid-action", "invalid-action-input", "invalid-role", "invalid-name", "reserved-name", "duplicate-name", "invalid-entity-id", "duplicate-entity-id", "missing-label", "missing-description", "invalid-title", "invalid-options", "invalid-default", "invalid-constraint", "unknown-relationship-target", "inverse-collision", "invalid-on-delete", "invalid-phrase", "invalid-index", "unknown-reference", "invalid-renamed-from", "invalid-guide", "managed-without-effect", "missing-permissions", "invalid-permission", "unknown-permission", "removed-allow", "unreachable-action", "wildcard-permission", "invalid-sign-in", "invalid-connection", "unknown-connection", "unused-connection", "invalid-prepare", "invalid-tool-name", "invalid-alignment", "single-entity-model-measure"]>;
         /** Where the problem is, for example `lead.properties.status.options[1]`. */
         readonly path: Schema.String;
         readonly message: Schema.String;

package/dist/diagnostics.js

@@ -50,6 +50,8 @@ export const DIAGNOSTIC_CODES = [
     "unused-connection",
     "invalid-prepare",
     "invalid-tool-name",
+    "invalid-alignment",
+    "single-entity-model-measure",
 ];
 /** A problem `check` found in an ontology definition. */
 export const Diagnostic = Schema.Struct({

package/dist/index.d.ts

@@ -2,7 +2,7 @@ export { BlobValue, BlobUpload, uploads, BLOB_CONTENT_TYPES, MAX_BLOB_BYTES } fr
 export { warehouse, compatibleWarehouseColumn, warehouseColumnType, validateWarehouseSource, } from "./source.js";
 export type { WarehouseSource } from "./source.js";
 export { m } from "./measure.js";
-export type { AggregateDeclarations, AggregateOptions, Measure, MeasureColumnCondition, MeasureCondition, Measures, MeasureExpression, MeasureOptions, } from "./measure.js";
+export type { AggregateDeclarations, AggregateOptions, AlignmentGroup, Measure, MeasureColumnCondition, MeasureCondition, Measures, MeasureExpression, MeasureOptions, ModelMeasure, ModelMeasureOptions, ModelMeasures, } from "./measure.js";
 export { MEASURE_CONDITION_OPERATORS } from "./aggregate-filters.js";
 export type { AggregateValue, MeasureConditionOperator } from "./aggregate-filters.js";
 export { action, isAction } from "./action.js";
@@ -16,7 +16,7 @@ export { entity, isEntity } from "./entity.js";
 export type { ActionsBuilder, AnyEntity, AnyStoredEntity, CreateValues, DraftEntity, Entity, EntityDefinition, EntityRecord, IndexDefinition, IndexField, NoActions, Properties, RecordRef, Relationships, SystemFields, UpdateValues, } from "./entity.js";
 export { ActionRejected, Conflict, NotFound, PermissionDenied } from "./errors.js";
 export type { ActionError } from "./errors.js";
-export { ActionManifest, actionConnectionKeys, canonicalJson, ConnectionManifest, EntityManifest, EntityPermissionsManifest, decodeManifestDocument, encodeManifest, formatManifest, IndexManifest, isValueMatched, MANIFEST_VERSION, manifestHash, OntologyManifest, OntologyManifestWire, PropertyManifest, RelationshipManifest, RoleManifest, SelectOptionManifest, SignInManifest, signInPolicyOf, } from "./manifest.js";
+export { ActionManifest, actionConnectionKeys, canonicalJson, ConnectionManifest, EntityManifest, EntityPermissionsManifest, decodeManifestDocument, encodeManifest, formatManifest, IndexManifest, isValueMatched, MANIFEST_VERSION, manifestHash, ModelMeasureManifest, OntologyManifest, OntologyManifestWire, PropertyManifest, RelationshipManifest, RoleManifest, SelectOptionManifest, SignInManifest, signInPolicyOf, } from "./manifest.js";
 export { SYSTEM_PROPERTIES } from "./names.js";
 export type { SystemProperty } from "./names.js";
 export { check, defineOntology } from "./ontology.js";

package/dist/index.js

@@ -7,7 +7,7 @@ export { CONNECTION_ERROR_REASONS, CONNECTION_KEY, CONNECTION_METHODS, connectio
 export { Diagnostic, DIAGNOSTIC_CODES, formatDiagnostics, InvalidOntology } from "./diagnostics.js";
 export { entity, isEntity } from "./entity.js";
 export { ActionRejected, Conflict, NotFound, PermissionDenied } from "./errors.js";
-export { ActionManifest, actionConnectionKeys, canonicalJson, ConnectionManifest, EntityManifest, EntityPermissionsManifest, decodeManifestDocument, encodeManifest, formatManifest, IndexManifest, isValueMatched, MANIFEST_VERSION, manifestHash, OntologyManifest, OntologyManifestWire, PropertyManifest, RelationshipManifest, RoleManifest, SelectOptionManifest, SignInManifest, signInPolicyOf, } from "./manifest.js";
+export { ActionManifest, actionConnectionKeys, canonicalJson, ConnectionManifest, EntityManifest, EntityPermissionsManifest, decodeManifestDocument, encodeManifest, formatManifest, IndexManifest, isValueMatched, MANIFEST_VERSION, manifestHash, ModelMeasureManifest, OntologyManifest, OntologyManifestWire, PropertyManifest, RelationshipManifest, RoleManifest, SelectOptionManifest, SignInManifest, signInPolicyOf, } from "./manifest.js";
 export { SYSTEM_PROPERTIES } from "./names.js";
 export { check, defineOntology } from "./ontology.js";
 export { DEFAULT_MEMBER_PERMISSIONS, generatedActionPermissions, grants, isAllowed, parsePermission, permissionsOf, READ_VERB, rolesGranting, WILDCARD, } from "./permissions.js";