@segmentstream/ontology 0.0.0-stage → 0.92.0

package/dist/legacy.d.ts

@@ -0,0 +1,160 @@
+/**
+ * @legacy ontology.metric-earlier-names
+ * Metrics were called measures before manifest version 14, and metric queries aggregates. This
+ * module is the one place that still knows the earlier names: workspace code written for an earlier
+ * SDK declares `measures` and calls an entity's `aggregate`, older app SDKs send `measures` and
+ * `orderBy[].measure` to the metric query routes at their earlier paths, `…/aggregate`, and
+ * deployments built by an earlier SDK store manifests with `measures` and `{ op: "measure", name }`
+ * expression nodes. Published manifests use only the current names; API catalogs retain deprecated
+ * aliases for released readers. Version 14 renames measures to metrics: entities' and the model's `metrics`,
+ * and `metric` expression nodes (`{ op: "metric", name }`, formerly `op: "measure"`).
+ */
+import { Effect, Schema } from "effect";
+import { type MetricConditionOperator, type MetricQueryValue } from "./metric-filters.js";
+import type { Metric, MetricColumnCondition, MetricCondition, MetricExpression, MetricOptions, Metrics, ModelMetric, ModelMetricOptions, ModelMetrics } from "./metric.js";
+import type { EntityRecord, FreshMetricQueryInput, FreshMetricQueryRow, MetricQueryGroupKey } from "./entity.js";
+import type { FreshMetricQueryOptions, OntologyReads, StoredRecord } from "./runtime.js";
+/** @deprecated Use {@link Metric}; measures are called metrics since manifest version 14. */
+export type Measure = Metric;
+/** @deprecated Use {@link Metrics}. */
+export type Measures = Metrics;
+/** @deprecated Use {@link MetricExpression}. */
+export type MeasureExpression = MetricExpression;
+/** @deprecated Use {@link MetricOptions}. */
+export type MeasureOptions = MetricOptions;
+/** @deprecated Use {@link MetricCondition}. */
+export type MeasureCondition = MetricCondition;
+/** @deprecated Use {@link MetricColumnCondition}. */
+export type MeasureColumnCondition = MetricColumnCondition;
+/** @deprecated Use {@link ModelMetric}. */
+export type ModelMeasure = ModelMetric;
+/** @deprecated Use {@link ModelMetricOptions}. */
+export type ModelMeasureOptions = ModelMetricOptions;
+/** @deprecated Use {@link ModelMetrics}. */
+export type ModelMeasures = ModelMetrics;
+/** @deprecated Use {@link MetricConditionOperator}. */
+export type MeasureConditionOperator = MetricConditionOperator;
+/** @deprecated Use {@link METRIC_CONDITION_OPERATORS}. */
+export declare const MEASURE_CONDITION_OPERATORS: readonly ["equals", "in", "notEquals", "notIn", "isNull", "isNotNull", "between", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith"];
+/** @deprecated Use `ModelMetricManifest`. */
+export { ModelMetricManifest as ModelMeasureManifest } from "./manifest.js";
+/** @deprecated Use {@link MetricQueryValue}. */
+export type AggregateValue = MetricQueryValue;
+/** @deprecated Use {@link MetricQueryGroupKey}. */
+export type AggregateGroupKey<P, R> = MetricQueryGroupKey<P, R>;
+/** @deprecated Use {@link FreshMetricQueryRow}. */
+export type FreshAggregateRow<Record, Group extends keyof Record, Metric extends string> = FreshMetricQueryRow<Record, Group, Metric>;
+/** @deprecated Use {@link FreshMetricQueryOptions}. */
+export type FreshAggregateOptions<R = StoredRecord, L extends string = never, Metric extends string = string, Group extends string = string> = EarlierFreshMetricQueryOptions<R, L, Metric, Group>;
+/** The earlier spelling of an entity's or the model's `metrics`, which declarations still accept. */
+export interface EarlierMetricsField<M> {
+    /** @deprecated Use `metrics`: `measures` is its earlier name. Declaring both is an error. */
+    readonly measures?: M;
+}
+/** A warehouse-backed entity's metrics under the name released app SDKs read for their types. */
+export interface EarlierMetricsName<M> {
+    /** @deprecated Use `metrics`: `measures` is its earlier name. */
+    readonly measures: M;
+}
+/** The earlier property shares the metrics themselves and their declared names. */
+export declare function withEarlierMetricsName<M>(metrics: M): EarlierMetricsName<M>;
+/** A name an SDK release replaced. */
+export interface EarlierName {
+    /** The name earlier SDKs used, which this one still accepts as a deprecated alias. */
+    readonly earlier: string;
+    /** The name that replaced it. */
+    readonly current: string;
+}
+/**
+ * A record, such as a fresh metric query's options, with an earlier `measures` and no `metrics` as
+ * one with `metrics`; others as given. Definitions use {@link withCurrentDefinitionNames}.
+ */
+export declare function withCurrentMetricsField<T extends object>(record: T): T;
+/**
+ * An `entity(…)` or `defineOntology(…)` definition with each field it declares under an earlier name
+ * only renamed to the current one; without such a field, the definition itself. The earlier names
+ * stay known to {@link earlierNamesOf}, for `check`.
+ */
+export declare function withCurrentDefinitionNames<T extends object>(definition: T): T;
+/**
+ * The earlier names a definition uses, for `check` to warn about: those
+ * {@link withCurrentDefinitionNames} renamed in it, or those it still declares itself. A field
+ * declared under both names is not among them; {@link earlierMetricsFieldProblem} refuses it.
+ */
+export declare function earlierNamesOf(definition: unknown): ReadonlyArray<EarlierName>;
+/**
+ * Why a definition's metrics cannot be read, for `check`: it declares them under both names. A
+ * definition with only one of them has no such problem.
+ */
+export declare function earlierMetricsFieldProblem(definition: unknown): string | undefined;
+/**
+ * A fresh metric query that names its metrics `measures`, as workspace code written for an earlier
+ * SDK does.
+ */
+export type EarlierFreshMetricQueryOptions<R, L extends string, Metric extends string, Group extends string> = Omit<FreshMetricQueryOptions<R, L, Metric, Group>, "metrics"> & {
+    /** @deprecated Use `metrics`: `measures` is its earlier name. */
+    readonly measures: readonly [Metric, ...Metric[]];
+};
+/**
+ * A fresh metric query's options with its metrics under `metrics`, whichever name the action used.
+ * Naming them under both is a mistake in the action's code, so it throws, as other malformed
+ * options fail the action.
+ */
+export declare function withCurrentFreshMetricQueryNames<R, L extends string, Metric extends string, Group extends string>(options: FreshMetricQueryOptions<R, L, Metric, Group> | EarlierFreshMetricQueryOptions<R, L, Metric, Group>): FreshMetricQueryOptions<R, L, Metric, Group>;
+/** The earlier name of an entity handle's `queryMetrics`, which action code may still call. */
+declare const EARLIER_QUERY_METRICS = "aggregate";
+/** An entity handle's `queryMetrics` under its earlier name. */
+export interface EarlierQueryMetricsName<P, R, M> {
+    /** @deprecated Use `queryMetrics`: `aggregate` is its earlier name. */
+    aggregate<const Metric extends keyof M & string, const Group extends MetricQueryGroupKey<P, R> = never>(options: FreshMetricQueryInput<P, R, Metric, Group>): Effect.Effect<ReadonlyArray<FreshMetricQueryRow<EntityRecord<P, R>, Group, Metric>>, never, OntologyReads>;
+}
+/** The members an entity handle carries under their earlier names. */
+export declare function withEarlierQueryMetricsName<QueryMetrics>(queryMetrics: QueryMetrics): {
+    readonly [EARLIER_QUERY_METRICS]: QueryMetrics;
+};
+/**
+ * A manifest document with the earlier names renamed: an entity's or the top-level `measures`
+ * becomes `metrics`, and every `{ op: "measure" }` node of their expressions `{ op: "metric" }`.
+ * A pure function on the raw JSON: the input is never changed, and is returned itself when it
+ * carries no earlier name, so a document's hash is always computed over what was stored. Every
+ * decode of `OntologyManifest` reads documents through it, and readers that serve stored documents
+ * use it to answer with the current names.
+ */
+export declare function withCurrentManifestNames(document: Readonly<Record<string, unknown>>): Readonly<Record<string, unknown>>;
+export declare function withCurrentManifestNames(document: unknown): unknown;
+/**
+ * The inverse of {@link withCurrentManifestNames}, for a manifest of a version before 14 that is
+ * encoded again: its document keeps the names it was hashed with.
+ */
+export declare function withEarlierManifestNames(document: Readonly<Record<string, unknown>>): Readonly<Record<string, unknown>>;
+/** A catalog metric's expression in the spelling released clients understand. */
+export declare function withEarlierMetricExpression(expression: unknown): unknown;
+/**
+ * An API catalog in current names with deprecated `measures` aliases on the model and its entities.
+ * Only the aliases use `measure` expression nodes. Stored documents and their hashes stay untouched.
+ */
+export declare function withEarlierCatalogNames(document: Readonly<Record<string, unknown>>): Readonly<Record<string, unknown>>;
+/**
+ * A manifest schema that reads documents of every version: each is renamed with
+ * {@link withCurrentManifestNames} before the schema decodes it. Being a declaration, it keeps
+ * doing so on its type side, so `Schema.toType` of it accepts the earlier names too.
+ */
+export declare function acceptingEarlierManifestNames<S extends Schema.Top>(schema: S): Schema.declareConstructor<S["Type"], S["Encoded"], readonly [S]>;
+/**
+ * The earlier name of the ontology service's metric query routes, `/api/ontology/aggregate` and
+ * `/api/ontology/<entity>/aggregate`, which older app SDKs still call: both are served, and the
+ * name stays reserved for entities and metrics of the model.
+ */
+export declare const EARLIER_QUERY_METRICS_ROUTE = "aggregate";
+/**
+ * A metric query's body with the earlier names renamed: `measures` becomes `metrics`, and an
+ * order's `measure` its `metric`. A body that names one of them twice is returned as it is, for the
+ * schema to refuse; a body without earlier names is returned itself.
+ */
+export declare function withCurrentMetricQueryNames(body: unknown): unknown;
+/**
+ * A metric query schema that also reads the earlier names older app SDKs send, through
+ * {@link withCurrentMetricQueryNames}, and refuses a request that uses both names for one field. Its
+ * type side is `schema` itself, which documents the current names only.
+ */
+export declare function acceptingEarlierMetricQueryNames<S extends Schema.Top>(schema: S): Schema.decodeTo<S, Schema.Unknown, never, never>;

package/dist/legacy.js

@@ -0,0 +1,270 @@
+/**
+ * @legacy ontology.metric-earlier-names
+ * Metrics were called measures before manifest version 14, and metric queries aggregates. This
+ * module is the one place that still knows the earlier names: workspace code written for an earlier
+ * SDK declares `measures` and calls an entity's `aggregate`, older app SDKs send `measures` and
+ * `orderBy[].measure` to the metric query routes at their earlier paths, `…/aggregate`, and
+ * deployments built by an earlier SDK store manifests with `measures` and `{ op: "measure", name }`
+ * expression nodes. Published manifests use only the current names; API catalogs retain deprecated
+ * aliases for released readers. Version 14 renames measures to metrics: entities' and the model's `metrics`,
+ * and `metric` expression nodes (`{ op: "metric", name }`, formerly `op: "measure"`).
+ */
+import { Effect, Schema, SchemaIssue, SchemaParser, SchemaTransformation } from "effect";
+import { METRIC_CONDITION_OPERATORS, } from "./metric-filters.js";
+/** The earlier name of `metrics`, in definitions, manifests and metric queries. */
+const EARLIER_METRICS = "measures";
+/** The earlier name of an order's `metric`, and of a `metric` expression node's `op`. */
+const EARLIER_METRIC = "measure";
+const METRICS = "metrics";
+const METRIC = "metric";
+/** @deprecated Use {@link METRIC_CONDITION_OPERATORS}. */
+export const MEASURE_CONDITION_OPERATORS = METRIC_CONDITION_OPERATORS;
+/** @deprecated Use `ModelMetricManifest`. */
+export { ModelMetricManifest as ModelMeasureManifest } from "./manifest.js";
+/** The earlier property shares the metrics themselves and their declared names. */
+export function withEarlierMetricsName(metrics) {
+    return { measures: metrics };
+}
+const METRICS_NAME = { earlier: EARLIER_METRICS, current: METRICS };
+/**
+ * The fields of `entity(…)` and `defineOntology(…)` definitions that SDK releases renamed. A rename
+ * adds one entry: definitions accept the earlier name, and `check` warns where workspace code still
+ * uses it, naming the current one.
+ */
+const RENAMED_DEFINITION_FIELDS = [METRICS_NAME];
+/** The earlier names of each definition {@link withCurrentDefinitionNames} renamed. */
+const earlierNamesRenamed = new WeakMap();
+/** The renamed fields a record declares under their earlier name only. */
+function earlierNamesIn(record, names) {
+    const fields = record;
+    return names.filter(({ earlier, current }) => fields[earlier] !== undefined && fields[current] === undefined);
+}
+/** The record with those fields under their current names, each in its place among the others. */
+function withCurrentNames(record, names) {
+    return names.reduce((fields, { earlier, current }) => renamedKey(Object.fromEntries(Object.entries(fields).filter(([key]) => key !== current)), earlier, current), record);
+}
+/**
+ * A record, such as a fresh metric query's options, with an earlier `measures` and no `metrics` as
+ * one with `metrics`; others as given. Definitions use {@link withCurrentDefinitionNames}.
+ */
+export function withCurrentMetricsField(record) {
+    return withCurrentNames(record, earlierNamesIn(record, [METRICS_NAME]));
+}
+/**
+ * An `entity(…)` or `defineOntology(…)` definition with each field it declares under an earlier name
+ * only renamed to the current one; without such a field, the definition itself. The earlier names
+ * stay known to {@link earlierNamesOf}, for `check`.
+ */
+export function withCurrentDefinitionNames(definition) {
+    const names = earlierNamesIn(definition, RENAMED_DEFINITION_FIELDS);
+    if (names.length === 0) {
+        return definition;
+    }
+    const renamed = withCurrentNames(definition, names);
+    earlierNamesRenamed.set(renamed, names);
+    return renamed;
+}
+/**
+ * The earlier names a definition uses, for `check` to warn about: those
+ * {@link withCurrentDefinitionNames} renamed in it, or those it still declares itself. A field
+ * declared under both names is not among them; {@link earlierMetricsFieldProblem} refuses it.
+ */
+export function earlierNamesOf(definition) {
+    return isRecord(definition)
+        ? (earlierNamesRenamed.get(definition) ?? earlierNamesIn(definition, RENAMED_DEFINITION_FIELDS))
+        : [];
+}
+/**
+ * Why a definition's metrics cannot be read, for `check`: it declares them under both names. A
+ * definition with only one of them has no such problem.
+ */
+export function earlierMetricsFieldProblem(definition) {
+    return isRecord(definition) &&
+        definition[EARLIER_METRICS] !== undefined &&
+        definition[METRICS] !== undefined
+        ? "Declare metrics once, under metrics; measures is their earlier name."
+        : undefined;
+}
+/**
+ * A fresh metric query's options with its metrics under `metrics`, whichever name the action used.
+ * Naming them under both is a mistake in the action's code, so it throws, as other malformed
+ * options fail the action.
+ */
+export function withCurrentFreshMetricQueryNames(options) {
+    const problem = earlierMetricsFieldProblem(options);
+    if (problem !== undefined) {
+        throw new TypeError(problem);
+    }
+    return withCurrentMetricsField(options);
+}
+/** The earlier name of an entity handle's `queryMetrics`, which action code may still call. */
+const EARLIER_QUERY_METRICS = "aggregate";
+/** The members an entity handle carries under their earlier names. */
+export function withEarlierQueryMetricsName(queryMetrics) {
+    return { [EARLIER_QUERY_METRICS]: queryMetrics };
+}
+export function withCurrentManifestNames(document) {
+    return renamedManifest(document, { from: EARLIER_METRICS, to: METRICS }, EARLIER_METRIC, METRIC);
+}
+/**
+ * The inverse of {@link withCurrentManifestNames}, for a manifest of a version before 14 that is
+ * encoded again: its document keeps the names it was hashed with.
+ */
+export function withEarlierManifestNames(document) {
+    return renamedManifest(document, { from: METRICS, to: EARLIER_METRICS }, METRIC, EARLIER_METRIC);
+}
+/** A catalog metric's expression in the spelling released clients understand. */
+export function withEarlierMetricExpression(expression) {
+    return renamedExpression(expression, METRIC, EARLIER_METRIC, 0);
+}
+/**
+ * An API catalog in current names with deprecated `measures` aliases on the model and its entities.
+ * Only the aliases use `measure` expression nodes. Stored documents and their hashes stay untouched.
+ */
+export function withEarlierCatalogNames(document) {
+    const current = withCurrentManifestNames(document);
+    const aliases = (owner) => Object.hasOwn(owner, METRICS)
+        ? { ...owner, [EARLIER_METRICS]: renamedMetrics(owner[METRICS], METRIC, EARLIER_METRIC) }
+        : owner;
+    const catalog = aliases(current);
+    return Array.isArray(current.entities)
+        ? {
+            ...catalog,
+            entities: changedItems(current.entities, (entity) => isRecord(entity) ? aliases(entity) : entity),
+        }
+        : catalog;
+}
+/**
+ * A manifest schema that reads documents of every version: each is renamed with
+ * {@link withCurrentManifestNames} before the schema decodes it. Being a declaration, it keeps
+ * doing so on its type side, so `Schema.toType` of it accepts the earlier names too.
+ */
+export function acceptingEarlierManifestNames(schema) {
+    return Schema.declareConstructor()([schema], ([codec]) => (input, _ast, options) => SchemaParser.decodeUnknownEffect(codec)(withCurrentManifestNames(input), options));
+}
+// Metric queries of the ontology service.
+/**
+ * The earlier name of the ontology service's metric query routes, `/api/ontology/aggregate` and
+ * `/api/ontology/<entity>/aggregate`, which older app SDKs still call: both are served, and the
+ * name stays reserved for entities and metrics of the model.
+ */
+export const EARLIER_QUERY_METRICS_ROUTE = "aggregate";
+/**
+ * A metric query's body with the earlier names renamed: `measures` becomes `metrics`, and an
+ * order's `measure` its `metric`. A body that names one of them twice is returned as it is, for the
+ * schema to refuse; a body without earlier names is returned itself.
+ */
+export function withCurrentMetricQueryNames(body) {
+    if (!isRecord(body)) {
+        return body;
+    }
+    let renamed = body;
+    if (Object.hasOwn(body, EARLIER_METRICS) && !Object.hasOwn(body, METRICS)) {
+        renamed = renamedKey(body, EARLIER_METRICS, METRICS);
+    }
+    if (Array.isArray(body.orderBy)) {
+        const orders = changedItems(body.orderBy, (order) => isRecord(order) && Object.hasOwn(order, EARLIER_METRIC) && !Object.hasOwn(order, METRIC)
+            ? renamedKey(order, EARLIER_METRIC, METRIC)
+            : order);
+        if (orders !== body.orderBy) {
+            renamed = { ...renamed, orderBy: orders };
+        }
+    }
+    return renamed;
+}
+/** Where a metric query names something under both names, if it does. */
+function metricQueryNameConflict(body) {
+    if (!isRecord(body)) {
+        return undefined;
+    }
+    if (Object.hasOwn(body, EARLIER_METRICS) && Object.hasOwn(body, METRICS)) {
+        return [EARLIER_METRICS];
+    }
+    const orders = Array.isArray(body.orderBy) ? body.orderBy : [];
+    const index = orders.findIndex((order) => isRecord(order) && Object.hasOwn(order, EARLIER_METRIC) && Object.hasOwn(order, METRIC));
+    return index === -1 ? undefined : ["orderBy", index, EARLIER_METRIC];
+}
+/**
+ * A metric query schema that also reads the earlier names older app SDKs send, through
+ * {@link withCurrentMetricQueryNames}, and refuses a request that uses both names for one field. Its
+ * type side is `schema` itself, which documents the current names only.
+ */
+export function acceptingEarlierMetricQueryNames(schema) {
+    return Schema.Unknown.pipe(Schema.decodeTo(schema, SchemaTransformation.transformEffect({
+        decode: (body, options) => {
+            const conflict = metricQueryNameConflict(body);
+            return conflict === undefined
+                ? Effect.succeed(withCurrentMetricQueryNames(body))
+                : Effect.fail(new SchemaIssue.Pointer(conflict, new SchemaIssue.InvalidValue({
+                    message: conflict.length === 1
+                        ? "Send metrics only; measures is their earlier name."
+                        : "Send metric only; measure is its earlier name.",
+                }, body, options)));
+        },
+        encode: (body) => Effect.succeed(body),
+    })));
+}
+// Helpers.
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/** The record with one key renamed, in its place among the others. */
+function renamedKey(record, from, to) {
+    return Object.fromEntries(Object.entries(record).map(([key, value]) => [key === from ? to : key, value]));
+}
+/** The items mapped, or the same array when no item changed. */
+function changedItems(items, map) {
+    const mapped = items.map(map);
+    return mapped.some((item, index) => item !== items[index]) ? mapped : items;
+}
+/** How deep renaming follows an expression: deeper than `check` lets any metric expression nest. */
+const MAXIMUM_EXPRESSION_DEPTH = 64;
+/** An expression with every `op: from` node renamed to `op: to`, nested arguments included. */
+function renamedExpression(value, from, to, depth) {
+    if (!isRecord(value) || depth > MAXIMUM_EXPRESSION_DEPTH) {
+        return value;
+    }
+    const args = Array.isArray(value.args)
+        ? changedItems(value.args, (arg) => renamedExpression(arg, from, to, depth + 1))
+        : value.args;
+    if (value.op !== from && args === value.args) {
+        return value;
+    }
+    return {
+        ...value,
+        ...(value.op === from ? { op: to } : {}),
+        ...(args === value.args ? {} : { args }),
+    };
+}
+/** A list of metrics with their expressions renamed. */
+function renamedMetrics(metrics, from, to) {
+    return Array.isArray(metrics)
+        ? changedItems(metrics, (metric) => {
+            if (!isRecord(metric)) {
+                return metric;
+            }
+            const expression = renamedExpression(metric.expression, from, to, 0);
+            return expression === metric.expression ? metric : { ...metric, expression };
+        })
+        : metrics;
+}
+/** An entity's or the manifest's record with its list of metrics under its new key, renamed. */
+function renamedOwner(owner, keys, from, to) {
+    const key = Object.hasOwn(owner, keys.from) && !Object.hasOwn(owner, keys.to) ? keys.from : keys.to;
+    const metrics = owner[key];
+    const renamed = renamedMetrics(metrics, from, to);
+    if (key === keys.to && renamed === metrics) {
+        return owner;
+    }
+    return Object.fromEntries(Object.entries(owner).map(([name, value]) => name === key ? [keys.to, renamed] : [name, value]));
+}
+function renamedManifest(document, keys, from, to) {
+    if (!isRecord(document)) {
+        return document;
+    }
+    const entities = Array.isArray(document.entities)
+        ? changedItems(document.entities, (entity) => isRecord(entity) ? renamedOwner(entity, keys, from, to) : entity)
+        : document.entities;
+    const renamed = renamedOwner(document, keys, from, to);
+    return entities === document.entities ? renamed : { ...renamed, entities };
+}

package/dist/manifest-compatibility.d.ts

@@ -0,0 +1,8 @@
+import { type OntologyManifest } from "./manifest.js";
+/**
+ * Whether two manifests differ only in presentation metadata: labels, descriptions, guides, display
+ * hints and relationship phrases. Pages and forwarded reads of one keep working against the other,
+ * because its schema, permissions and sign-in policy are the same. It is not permission evidence:
+ * live users, exact roles and revocations still apply.
+ */
+export declare function browserAuthenticationCompatible(left: OntologyManifest, right: OntologyManifest): boolean;

package/dist/manifest-compatibility.js

@@ -0,0 +1,87 @@
+import { canonicalJson, encodeManifest, MANIFEST_VERSION, } from "./manifest.js";
+/** The first version whose documents name metrics as this SDK does. */
+const FIRST_COMPARABLE_VERSION = 14;
+// @legacy ontology.workflow-cutover-artifacts
+/**
+ * Capabilities ontology SDKs 0.86.0 to 0.88.0 declared for a deploy guard that was withdrawn.
+ * Nothing reads them, so a manifest that declares them equals one that does not.
+ */
+const WITHDRAWN_CAPABILITIES = [
+    "workflow-execution-compatibility-v1",
+    "workflow-admission-v1",
+    "workflow-execution-extension-v1",
+];
+function record(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function omit(value, fields) {
+    return Object.fromEntries(Object.entries(value).filter(([key]) => !fields.includes(key)));
+}
+function mapRecords(value, project) {
+    return Array.isArray(value) ? value.map((item) => (record(item) ? project(item) : item)) : value;
+}
+/**
+ * Explicit presentation fields only. Never recursively strip keywords: JSON Schema's descriptions,
+ * defaults and arbitrary scope predicates stay opaque, as do fields this SDK does not understand.
+ */
+function entityWithoutPresentation(entity) {
+    const projected = omit(entity, ["label", "plural", "description", "guide"]);
+    return {
+        ...projected,
+        properties: mapRecords(entity.properties, (property) => ({
+            ...omit(property, ["label", "description", "display"]),
+            ...(property.options === undefined
+                ? {}
+                : {
+                    options: mapRecords(property.options, (option) => omit(option, ["label", "description"])),
+                }),
+        })),
+        relationships: mapRecords(entity.relationships, (relationship) => omit(relationship, ["phrase", "description"])),
+        actions: mapRecords(entity.actions, (action) => omit(action, ["description"])),
+    };
+}
+/**
+ * A manifest without its presentation metadata, version and hash; undefined for a version whose
+ * documents this SDK cannot compare. Earlier versions name metrics differently.
+ */
+function withoutPresentation(manifest) {
+    const document = encodeManifest(manifest);
+    if (manifest.version < FIRST_COMPARABLE_VERSION ||
+        manifest.version > MANIFEST_VERSION ||
+        document.version !== manifest.version) {
+        return undefined;
+    }
+    return {
+        // @legacy ontology.workflow-cutover-artifacts
+        ...omit(document, ["hash", "version", "executionCompatibility"]),
+        runtimeCapabilities: Array.isArray(document.runtimeCapabilities)
+            ? document.runtimeCapabilities.filter((value) => !WITHDRAWN_CAPABILITIES.includes(value))
+            : document.runtimeCapabilities,
+        entities: mapRecords(document.entities, entityWithoutPresentation),
+        roles: mapRecords(document.roles, (role) => omit(role, ["description"])),
+        ...(document.connections === undefined
+            ? {}
+            : {
+                connections: mapRecords(document.connections, (connection) => omit(connection, ["description"])),
+            }),
+        ...(document.workflows === undefined
+            ? {}
+            : {
+                workflows: mapRecords(document.workflows, (workflow) => ({
+                    ...omit(workflow, ["description"]),
+                    triggers: mapRecords(workflow.triggers, (trigger) => omit(trigger, ["description"])),
+                })),
+            }),
+    };
+}
+/**
+ * Whether two manifests differ only in presentation metadata: labels, descriptions, guides, display
+ * hints and relationship phrases. Pages and forwarded reads of one keep working against the other,
+ * because its schema, permissions and sign-in policy are the same. It is not permission evidence:
+ * live users, exact roles and revocations still apply.
+ */
+export function browserAuthenticationCompatible(left, right) {
+    const a = withoutPresentation(left);
+    const b = withoutPresentation(right);
+    return a !== undefined && b !== undefined && canonicalJson(a) === canonicalJson(b);
+}