@salsita-ai/sdk 0.50.0-develop.dede205ab0 → 0.50.0-develop.df1d25280c

package/dist/domain/core/emission/transformer-log.d.ts

@@ -0,0 +1,11 @@
+import type { StateUpdate } from '../component/index.js';
+import type { DomainEntity } from '../model/index.js';
+import type { TransformerLogEntry } from './transformer-log-entry.js';
+import type { TransformerPhase } from './transformer-phase.js';
+export interface TransformerLog {
+    name: string;
+    entries: readonly TransformerLogEntry[];
+    status: TransformerPhase;
+    updatesIn: ReadonlyArray<StateUpdate<DomainEntity<string>, DomainEntity<string>>>;
+    updatesOut: ReadonlyArray<StateUpdate<DomainEntity<string>, DomainEntity<string>>>;
+}

package/dist/domain/core/emission/transformer-log.js

@@ -0,0 +1 @@
+export{};

package/dist/domain/core/emission/transformer-phase.d.ts

@@ -0,0 +1 @@
+export type TransformerPhase = 'no-event' | 'no-match' | 'no-resolve' | 'match' | 'no-apply' | 'apply';

package/dist/domain/core/emission/transformer-phase.js

@@ -0,0 +1 @@
+export{};

package/dist/domain/core/expression/aliased-expressions.d.ts

@@ -5,6 +5,6 @@ import type { AnonymousExpression } from './expression.js';
  * It is what `implementCustomExpressions` returns and what the domain is built from; an alias key
  * stands for every entity type the alias expands to.
  */
-export type AliasedExpressions<ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, ALIASES extends Record<string, ENTITIES>> = {
-    [K in TypeOrAlias<ENTITIES, ALIASES>]?: Record<string, AnonymousExpression<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ExpandAlias<ENTITIES, ALIASES, K>, unknown>>;
+export type AliasedExpressions<ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, ALIASES extends Record<string, ENTITIES>, CONTEXT_EXTENSION = unknown> = {
+    [K in TypeOrAlias<ENTITIES, ALIASES>]?: Record<string, AnonymousExpression<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ExpandAlias<ENTITIES, ALIASES, K>, unknown, CONTEXT_EXTENSION>>;
 };

package/dist/domain/core/expression/constant-expressions.d.ts

@@ -1,8 +1,16 @@
-import type { DomainEntity, ExpandAlias, TypeOrAlias } from '../model/index.js';
-import type { AnonymousExpression, ExpressionMetas } from './expression.js';
-export type ConstantExpressions<ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, ALIASES extends Record<string, ENTITIES>, CONSTANTS extends Partial<Record<TypeOrAlias<ENTITIES, ALIASES>, Record<string, unknown>>>> = {
-    readonly [TYPE_OR_ALIAS in keyof CONSTANTS & string]: {
-        readonly [NAME in keyof CONSTANTS[TYPE_OR_ALIAS]]: AnonymousExpression<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ExpandAlias<ENTITIES, ALIASES, TYPE_OR_ALIAS>, CONSTANTS[TYPE_OR_ALIAS][NAME]>;
-    };
-};
-export declare const createConstantExpressionFactory: <ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, ALIASES extends Record<string, ENTITIES>>(metas: ExpressionMetas<ENTITIES, ALIASES>) => <CONSTANTS extends Partial<Record<TypeOrAlias<ENTITIES, ALIASES>, Record<string, unknown>>>>(constants: CONSTANTS) => ConstantExpressions<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ALIASES, CONSTANTS>;
+import type { ExpressionMeta } from './expression.js';
+/**
+ * The constant expressions of a domain, keyed by entity type or alias and then by the name of the
+ * constant. A constant expression takes no argument: it reads neither the entity nor the state, so
+ * the domain of any project accepts it.
+ */
+export type ConstantExpressions = Readonly<Record<string, Readonly<Record<string, {
+    evaluate(): unknown;
+    readonly meta: ExpressionMeta;
+}>>>>;
+/**
+ * Makes the function that turns the constants of a spec into expressions: every constant becomes an
+ * expression that returns its value. The type a project reads from a constant is the one its
+ * generated model declares for the property, not the type of the expression.
+ */
+export declare const createConstantExpressionFactory: () => (constants: Readonly<Record<string, Readonly<Record<string, unknown>>>>) => ConstantExpressions;

package/dist/domain/core/expression/constant-expressions.js

@@ -1 +1 @@
-import{mapNestedObject as t}from"../../utils/map-nested-object.js";export const createConstantExpressionFactory=e=>o=>t()(o,([t,o,a])=>[[t,o,{meta:e[t]?.[o]??{},evaluate:()=>a}]]);
+import{mapNestedObject as t}from"../../utils/map-nested-object.js";export const createConstantExpressionFactory=()=>e=>t()(e,([t,e,o])=>[[t,e,{meta:{},evaluate:()=>o}]]);

package/dist/domain/core/expression/custom-expression.d.ts

@@ -1,12 +1,25 @@
-import type { $DomainEntity, DomainEntity, EntityByType, TypeOrAlias } from '../model/index.js';
+import type { $DomainEntity, DomainEntity, DomainEntityId, TypeOrAlias } from '../model/index.js';
 import type { DomainState } from '../state/index.js';
 import type { AliasedExpressions } from './aliased-expressions.js';
-import type { AnonymousExpression, ExpressionContext, ExpressionMeta, ExpressionMetas } from './expression.js';
-export type CustomExpression<ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, SELF extends $DomainEntity<ENTITIES>, T> = (self: SELF, state: DomainState<ENTITIES>, ctx: ExpressionContext<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA>) => T;
-export type PotentialCustomExpressions<ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, $MAP extends Record<ENTITIES['type'], $DomainEntity<ENTITIES>>, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>> = {
+import type { ExpressionMeta, OpenExpressionContext } from './expression.js';
+export type CustomExpression<ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, SELF extends $DomainEntity<ENTITIES>, T, CONTEXT_EXTENSION = unknown> = (self: SELF, state: DomainState<ENTITIES>, ctx: OpenExpressionContext<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, CONTEXT_EXTENSION>) => T;
+export type PotentialCustomExpressions<ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, $MAP extends Record<ENTITIES['type'], $DomainEntity<ENTITIES>>, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, CONTEXT_EXTENSION = unknown> = {
     [TYPE_OR_ALIAS in keyof $MAP]?: {
-        [NAME in Extract<keyof $MAP[TYPE_OR_ALIAS], `$${string}`>]?: CustomExpression<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, $MAP[TYPE_OR_ALIAS], $MAP[TYPE_OR_ALIAS][NAME]>;
+        [NAME in Extract<keyof $MAP[TYPE_OR_ALIAS], `$${string}`>]?: CustomExpression<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, $MAP[TYPE_OR_ALIAS], $MAP[TYPE_OR_ALIAS][NAME], CONTEXT_EXTENSION>;
     };
 };
-export declare const createCustomExpressionFactory: <ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, $MAP extends Record<TypeOrAlias<ENTITIES, ALIASES>, $DomainEntity<ENTITIES>>, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, ALIASES extends Record<string, ENTITIES>>(metas: ExpressionMetas<ENTITIES, ALIASES>) => (implementations: PotentialCustomExpressions<ENTITIES, ALLOWED_ROOT_ENTITIES, $MAP, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA>) => AliasedExpressions<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ALIASES>;
-export declare const createCustomExpression: <ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, $SELF extends $DomainEntity<ENTITIES>, T>(evaluate: CustomExpression<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, $SELF, T>, meta: ExpressionMeta) => AnonymousExpression<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, EntityByType<ENTITIES, $SELF['type']>, T>;
+export declare const createCustomExpressionFactory: <ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, $MAP extends Record<TypeOrAlias<ENTITIES, ALIASES>, $DomainEntity<ENTITIES>>, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, ALIASES extends Record<string, ENTITIES>, CONTEXT_EXTENSION = unknown>() => (implementations: PotentialCustomExpressions<ENTITIES, ALLOWED_ROOT_ENTITIES, $MAP, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, CONTEXT_EXTENSION>) => AliasedExpressions<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ALIASES, CONTEXT_EXTENSION>;
+/**
+ * Wraps the function a project writes for an expression or for a filter criterion into an
+ * expression: the function receives the entity view of `selfId` instead of the id. It takes the
+ * types of the function as they are, so the expression it returns has the state and the context of
+ * the function, and it asks of the context only the entity view it reads itself.
+ */
+export declare const createCustomExpression: <SELF, STATE, CONTEXT extends {
+    readonly domain: {
+        get$Entity(id: DomainEntityId<string>, state: STATE): unknown;
+    };
+}, T>(evaluate: (self: SELF, state: STATE, ctx: CONTEXT) => T, meta: ExpressionMeta) => {
+    evaluate(selfId: DomainEntityId<string>, state: STATE, ctx: CONTEXT): T;
+    readonly meta: ExpressionMeta;
+};

package/dist/domain/core/expression/custom-expression.js

@@ -1 +1 @@
-import{mapNestedObject as e}from"../../utils/map-nested-object.js";export const createCustomExpressionFactory=t=>o=>e()(o,([e,o,r])=>{if(!r)throw Error(`Custom expression for ${e}.${o} is of type undefined`);return[[e,o,createCustomExpression(r,t[e]?.[o]??{})]]});export const createCustomExpression=(e,t)=>({evaluate:(t,o,r)=>e(r.domain.get$Entity(t,o),o,r),meta:t});
+import{mapNestedObject as e}from"../../utils/map-nested-object.js";export const createCustomExpressionFactory=()=>t=>e()(t,([e,t,o])=>{if(!o)throw Error(`Custom expression for ${e}.${t} is of type undefined`);return[[e,t,createCustomExpression(o,{})]]});export const createCustomExpression=(e,t)=>({evaluate:(t,o,r)=>e(r.domain.get$Entity(t,o),o,r),meta:t});

package/dist/domain/core/expression/expression.d.ts

@@ -1,11 +1,12 @@
 import type { SessionRole } from '@salsita-ai/contracts/api';
-import type { ComponentReader } from '../../domain-runtime/domain-context/index.js';
-import type { CollisionProjections, ConstraintProjections, PositionProjections, ProjectedEntitiesProjections, SnappingProjections } from '../../projections/index.js';
-import type { SketchingProjections } from '../../sketching/index.js';
 import type { Domain } from '../domain.js';
-import type { $DomainEntity, DomainEntity, TypeOrAlias } from '../model/index.js';
+import type { $DomainEntity, DomainEntity } from '../model/index.js';
 import type { DomainState, MigrateFunction } from '../state/index.js';
-export interface ExpressionContext<ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>> {
+/**
+ * The part of the expression context that core declares: the mode and role of the session, the data
+ * of the application, the entity view and the migration of the model.
+ */
+export interface CoreExpressionContext<ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>> {
     readonly mode: 'owner' | 'read' | 'finalize';
     readonly role: SessionRole;
     readonly publishedData: PUBLISHED_DATA;
@@ -13,23 +14,20 @@ export interface ExpressionContext<ENTITIES extends DomainEntity<string>, ALLOWE
     readonly backendData: Record<string, unknown> | undefined;
     readonly sessionData: SESSION_DATA;
     readonly domain: Domain<ENTITIES, ALLOWED_ROOT_ENTITIES, Record<ENTITIES['type'], $DomainEntity<ENTITIES>>>;
-    readonly componentReader: ComponentReader<ENTITIES>;
     readonly migrate: MigrateFunction<ENTITIES>;
-    readonly positionProjections: PositionProjections<ENTITIES>;
-    readonly sketchingProjections: SketchingProjections<ENTITIES>;
-    readonly collisionProjections: CollisionProjections<ENTITIES>;
-    readonly constraintProjections: ConstraintProjections<ENTITIES>;
-    readonly snappingProjections: SnappingProjections<ENTITIES>;
-    readonly projectedEntitiesProjections: ProjectedEntitiesProjections<ENTITIES>;
 }
-export type AnyExpressionContext = ExpressionContext<any, any, any, any, any>;
+/**
+ * The context an expression is evaluated in. Core declares its own part; `CONTEXT_EXTENSION` is
+ * what whoever evaluates the expression adds to it, such as the component reader and the
+ * projections of the domain runtime. An expression that reads only core's part leaves it out.
+ */
+export type OpenExpressionContext<ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, CONTEXT_EXTENSION = unknown> = CoreExpressionContext<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA> & CONTEXT_EXTENSION;
 export interface ExpressionMeta {
     /**
      * By enabling this flag, expression will be run during validation. It is primarily used to check validity of relations.
      */
     readonly alwaysEvaluate?: boolean;
 }
-export type ExpressionMetas<ENTITIES extends DomainEntity<string>, ALIASES extends Record<string, ENTITIES>> = Partial<Record<TypeOrAlias<ENTITIES, ALIASES>, Record<string, ExpressionMeta>>>;
 /**
  * Metadata used for debugging of expression exceptions.
  */
@@ -37,11 +35,11 @@ export interface ExpressionOrigin {
     readonly typeOrAlias: string;
     readonly name: string;
 }
-export interface AnonymousExpression<ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, SELF extends ENTITIES, T> {
-    evaluate(selfId: SELF['id'], state: DomainState<ENTITIES>, ctx: ExpressionContext<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA>): T;
+export interface AnonymousExpression<ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, SELF extends ENTITIES, T, CONTEXT_EXTENSION = unknown> {
+    evaluate(selfId: SELF['id'], state: DomainState<ENTITIES>, ctx: OpenExpressionContext<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, CONTEXT_EXTENSION>): T;
     readonly meta: ExpressionMeta;
 }
-export interface Expression<ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, SELF extends ENTITIES, T> extends AnonymousExpression<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, SELF, T> {
+export interface Expression<ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, SELF extends ENTITIES, T, CONTEXT_EXTENSION = unknown> extends AnonymousExpression<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, SELF, T, CONTEXT_EXTENSION> {
     readonly origin: ExpressionOrigin;
 }
 export type AnyExpression = Expression<any, any, any, any, any, any, any>;

package/dist/domain/core/index.d.ts

@@ -1,8 +1,10 @@
 export * from './action/index.js';
 export * from './component/index.js';
+export type * from './data-schema/index.js';
 export * from './decoder/index.js';
 export * from './domain-factory.js';
 export * from './domain.js';
+export type * from './emission/index.js';
 export * from './expression/index.js';
 export * from './invariant/index.js';
 export * from './model/index.js';

package/dist/domain/core/invariant/custom-invariants.d.ts

@@ -1,21 +1,13 @@
-import type { OmitEmpty, OmitNever } from '@salsita-ai/common/utils';
 import type { CustomExpression } from '../expression/index.js';
-import type { $DomainEntity, DomainEntity, ExpandAlias, TypeOrAlias } from '../model/index.js';
-import type { Invariant } from './invariants.js';
+import type { $DomainEntity, DomainEntity, TypeOrAlias } from '../model/index.js';
+import type { AliasedInvariants } from './invariants.js';
 import type { Violation } from './violation.js';
-export type CustomInvariantsFromBlueprints<ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, $MAP extends Record<ENTITIES['type'], $DomainEntity<ENTITIES>>, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, BLUEPRINTS extends Partial<Record<keyof $MAP & string, Record<string, boolean | string>>>> = {
+export type CustomInvariantsFromBlueprints<ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, $MAP extends Record<ENTITIES['type'], $DomainEntity<ENTITIES>>, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, BLUEPRINTS extends Partial<Record<keyof $MAP & string, Record<string, boolean | string>>>, CONTEXT_EXTENSION = unknown> = {
     [TYPE_OR_ALIAS in keyof BLUEPRINTS]: {
-        [NAME in keyof BLUEPRINTS[TYPE_OR_ALIAS]]: TYPE_OR_ALIAS extends keyof $MAP ? CustomExpression<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, $MAP[TYPE_OR_ALIAS], BLUEPRINTS[TYPE_OR_ALIAS][NAME] extends string ? ReadonlyArray<Violation<BLUEPRINTS[TYPE_OR_ALIAS][NAME]>> : BLUEPRINTS[TYPE_OR_ALIAS][NAME]> : never;
+        [NAME in keyof BLUEPRINTS[TYPE_OR_ALIAS]]: TYPE_OR_ALIAS extends keyof $MAP ? CustomExpression<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, $MAP[TYPE_OR_ALIAS], BLUEPRINTS[TYPE_OR_ALIAS][NAME] extends string ? ReadonlyArray<Violation<BLUEPRINTS[TYPE_OR_ALIAS][NAME]>> : BLUEPRINTS[TYPE_OR_ALIAS][NAME], CONTEXT_EXTENSION> : never;
     };
 };
-export type StaticallyDefinedViolations<ENTITIES extends DomainEntity<string>, ALIASES extends Record<string, ENTITIES>, BLUEPRINTS extends Partial<Record<TypeOrAlias<ENTITIES, ALIASES>, Record<string, boolean | string>>>> = OmitEmpty<{
-    [TYPE_OR_ALIAS in keyof BLUEPRINTS]: OmitNever<{
-        [NAME in keyof BLUEPRINTS[TYPE_OR_ALIAS]]: BLUEPRINTS[TYPE_OR_ALIAS][NAME] extends boolean ? Violation<string> : never;
-    }>;
-}>;
-export type InvariantsFromBlueprints<ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, ALIASES extends Record<string, ENTITIES>, BLUEPRINTS extends Partial<Record<TypeOrAlias<ENTITIES, ALIASES>, Record<string, boolean | string>>>, STATIC_VIOLATIONS extends StaticallyDefinedViolations<ENTITIES, ALIASES, BLUEPRINTS>, PICK extends keyof BLUEPRINTS = keyof BLUEPRINTS> = {
-    readonly [TYPE_OR_ALIAS in keyof BLUEPRINTS & string & PICK]: ReadonlyArray<{
-        [NAME in keyof BLUEPRINTS[TYPE_OR_ALIAS]]: Invariant<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ExpandAlias<ENTITIES, ALIASES, TYPE_OR_ALIAS>, BLUEPRINTS[TYPE_OR_ALIAS][NAME] extends boolean ? TYPE_OR_ALIAS extends keyof STATIC_VIOLATIONS ? NAME extends keyof STATIC_VIOLATIONS[TYPE_OR_ALIAS] ? STATIC_VIOLATIONS[TYPE_OR_ALIAS][NAME]['type'] : never : never : BLUEPRINTS[TYPE_OR_ALIAS][NAME] extends string ? BLUEPRINTS[TYPE_OR_ALIAS][NAME] : never>;
-    }[keyof BLUEPRINTS[TYPE_OR_ALIAS]]>;
-};
-export declare const createCustomInvariantFactory: <ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, $MAP extends Record<TypeOrAlias<ENTITIES, ALIASES>, $DomainEntity<ENTITIES>>, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, ALIASES extends Record<string, ENTITIES>, BLUEPRINTS extends Partial<Record<TypeOrAlias<ENTITIES, ALIASES>, Record<string, boolean | string>>>>() => <STATIC_VIOLATIONS extends StaticallyDefinedViolations<ENTITIES, ALIASES, BLUEPRINTS>>(staticViolations: STATIC_VIOLATIONS) => <TYPES_OR_ALIASES extends keyof BLUEPRINTS & string>(implementations: Pick<CustomInvariantsFromBlueprints<ENTITIES, ALLOWED_ROOT_ENTITIES, $MAP, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, BLUEPRINTS>, TYPES_OR_ALIASES>) => InvariantsFromBlueprints<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ALIASES, BLUEPRINTS, STATIC_VIOLATIONS, TYPES_OR_ALIASES>;
+/** The violation a static invariant reports when it does not hold, by entity type or alias and by invariant name. */
+type StaticViolations = Readonly<Record<string, Readonly<Record<string, Violation<string>>>>>;
+export declare const createCustomInvariantFactory: <ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, $MAP extends Record<TypeOrAlias<ENTITIES, ALIASES>, $DomainEntity<ENTITIES>>, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, ALIASES extends Record<string, ENTITIES>, BLUEPRINTS extends Partial<Record<TypeOrAlias<ENTITIES, ALIASES>, Record<string, boolean | string>>>, CONTEXT_EXTENSION = unknown>() => (staticViolations: StaticViolations) => <TYPES_OR_ALIASES extends keyof BLUEPRINTS & string>(implementations: Pick<CustomInvariantsFromBlueprints<ENTITIES, ALLOWED_ROOT_ENTITIES, $MAP, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, BLUEPRINTS, CONTEXT_EXTENSION>, TYPES_OR_ALIASES>) => AliasedInvariants<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ALIASES, string>;
+export {};

package/dist/domain/core/invariant/index.d.ts

@@ -1,5 +1,5 @@
 export * from './builtin-invariant.js';
 export * from './custom-invariants.js';
-export * from './invariants.js';
+export type * from './invariants.js';
 export * from './violation-component.js';
 export * from './violation.js';

package/dist/domain/core/invariant/index.js

@@ -1 +1 @@
-export*from"./builtin-invariant.js";export*from"./custom-invariants.js";export*from"./invariants.js";export*from"./violation-component.js";export*from"./violation.js";
+export*from"./builtin-invariant.js";export*from"./custom-invariants.js";export*from"./violation-component.js";export*from"./violation.js";

package/dist/domain/core/invariant/invariants.d.ts

@@ -1,76 +1,10 @@
-import type { OmitNever } from '@salsita-ai/common/utils';
-import { type ProjectModule } from '../../project-modules/index.js';
-import type { AnonymousExpression, ExpressionContext } from '../expression/index.js';
-import { type $DomainEntity, type AliasMap, type DomainEntity, type EntityByType, type EventualAlias, type ExpandAlias, type ExtractFromAliasedRecord, type TypeOrAlias } from '../model/index.js';
+import type { OpenExpressionContext } from '../expression/index.js';
+import type { DomainEntity, ExpandAlias, TypeOrAlias } from '../model/index.js';
 import type { DomainState } from '../state/index.js';
 import { type Violation } from './violation.js';
-export interface Invariant<ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, ENTITY extends ENTITIES, VIOLATION_TYPE extends string> {
-    evaluate(selfId: ENTITY['id'], state: DomainState<ENTITIES>, ctx: ExpressionContext<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA>): ReadonlyArray<Violation<VIOLATION_TYPE>>;
+export interface Invariant<ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, ENTITY extends ENTITIES, VIOLATION_TYPE extends string, CONTEXT_EXTENSION = unknown> {
+    evaluate(selfId: ENTITY['id'], state: DomainState<ENTITIES>, ctx: OpenExpressionContext<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, CONTEXT_EXTENSION>): ReadonlyArray<Violation<VIOLATION_TYPE>>;
 }
 export type AliasedInvariants<ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, ALIASES extends Record<string, ENTITIES>, VIOLATION_TYPES extends string> = {
     [K in TypeOrAlias<ENTITIES, ALIASES>]?: ReadonlyArray<Invariant<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ExpandAlias<ENTITIES, ALIASES, K>, VIOLATION_TYPES>>;
 };
-export type DeclaredInvariants<ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, $MAP extends Record<ENTITIES['type'], $DomainEntity<ENTITIES>>, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>> = {
-    readonly [TYPE in ENTITIES['type']]: '$violations' extends keyof $MAP[TYPE] ? $MAP[TYPE]['$violations'] extends () => ReadonlyArray<Violation<infer VIOLATION_TYPE>> ? ReadonlyArray<Invariant<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ENTITIES, VIOLATION_TYPE>> : never : never;
-};
-type ConflictingInvariants<ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, EXPECTED extends Partial<Record<ENTITIES['type'], ReadonlyArray<Invariant<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ENTITIES, string>>>>, IMPLEMENTED extends Partial<Record<ENTITIES['type'], ReadonlyArray<Invariant<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ENTITIES, string>>>>> = OmitNever<{
-    [K in keyof EXPECTED]: EXPECTED[K] extends [never] ? never : K extends keyof IMPLEMENTED ? ViolationTypeOfInvariants<EXPECTED[K]> extends ViolationTypeOfInvariants<IMPLEMENTED[K]> ? ViolationTypeOfInvariants<IMPLEMENTED[K]> extends ViolationTypeOfInvariants<EXPECTED[K]> ? never : {
-        missing: Exclude<ViolationTypeOfInvariants<EXPECTED[K]>, ViolationTypeOfInvariants<IMPLEMENTED[K]>>;
-        extra: Exclude<ViolationTypeOfInvariants<IMPLEMENTED[K]>, ViolationTypeOfInvariants<EXPECTED[K]>>;
-    } : {
-        missing: Exclude<ViolationTypeOfInvariants<EXPECTED[K]>, ViolationTypeOfInvariants<IMPLEMENTED[K]>>;
-        extra: Exclude<ViolationTypeOfInvariants<IMPLEMENTED[K]>, ViolationTypeOfInvariants<EXPECTED[K]>>;
-    } : {
-        missing: ViolationTypeOfInvariants<EXPECTED[K]>;
-        extra: never;
-    };
-}>;
-type ViolationOfInvariants<INVARIANTS> = INVARIANTS extends ReadonlyArray<infer INVARIANT> ? INVARIANT : never;
-type ViolationTypeOfInvariants<INVARIANTS> = ViolationOfInvariants<INVARIANTS> extends Invariant<any, any, any, any, any, any, infer VIOLATION_TYPE> ? VIOLATION_TYPE : never;
-type ExpandAndMergeInvariants<ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, ALIASES extends Readonly<Record<string, ENTITIES>>, EXPANDED extends Partial<Record<ENTITIES['type'], ReadonlyArray<Invariant<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ENTITIES, string>>>>, ALIASED extends Partial<Record<TypeOrAlias<ENTITIES, ALIASES>, ReadonlyArray<Invariant<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ENTITIES, string>>>>> = {
-    [K in keyof EXPANDED | ExpandAlias<ENTITIES, ALIASES, keyof ALIASED & string>['type']]: K extends ENTITIES['type'] ? ExtractFromAliasedRecord<ENTITIES, ALIASES, ALIASED, EventualAlias<ENTITIES, ALIASES, K> | K> extends infer INVARIANTS_FROM_ALIAS ? [
-        INVARIANTS_FROM_ALIAS
-    ] extends [never] ? K extends keyof EXPANDED ? EXPANDED[K] : never : K extends keyof EXPANDED ? ReadonlyArray<ViolationOfInvariants<EXPANDED[K]> | ViolationOfInvariants<INVARIANTS_FROM_ALIAS>> : ReadonlyArray<ViolationOfInvariants<INVARIANTS_FROM_ALIAS>> : never : never;
-};
-type ExpressionsFromInvariants<ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, INVARIANTS extends Partial<Record<ENTITIES['type'], ReadonlyArray<Invariant<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ENTITIES, string>>>>> = {
-    [K in keyof INVARIANTS & ENTITIES['type']]: {
-        $violations: AnonymousExpression<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, EntityByType<ENTITIES, K>, ReadonlyArray<Violation<INVARIANTS[K] extends ReadonlyArray<infer ELEMENT> ? ELEMENT extends Invariant<any, any, any, any, any, any, infer VIOLATION_TYPE> ? VIOLATION_TYPE : never : never>>>;
-    };
-};
-type BuildViolationExpressions<ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, $MAP extends Record<ENTITIES['type'], $DomainEntity<ENTITIES>>, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, INVARIANTS extends Partial<Record<ENTITIES['type'], ReadonlyArray<Invariant<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ENTITIES, string>>>>> = Record<never, never> extends ConflictingInvariants<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, DeclaredInvariants<ENTITIES, ALLOWED_ROOT_ENTITIES, $MAP, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA>, INVARIANTS> ? () => ExpressionsFromInvariants<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, INVARIANTS> : never;
-type AnyInvariant = Invariant<any, any, any, any, any, any, string>;
-/** Validates the `src/invariants/` files and concatenates their invariants per entity type or alias. */
-export declare const resolveInvariantModules: (modules: readonly ProjectModule[]) => Readonly<Record<string, readonly AnyInvariant[]>>;
-export declare class InvariantBuilder<ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, $MAP extends Record<ENTITIES['type'], $DomainEntity<ENTITIES>>, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, ALIASES extends Record<string, ENTITIES>, INVARIANTS extends Partial<Record<ENTITIES['type'], ReadonlyArray<Invariant<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ENTITIES, string>>>> = Record<never, never>> {
-    private readonly aliasMap;
-    private readonly invariants;
-    constructor(aliasMap: AliasMap<ALIASES>, invariants?: INVARIANTS);
-    /**
-     * Adds the invariants of the `src/invariants/` files, as the generated barrel lists them, after
-     * checking each file against the folder's contract.
-     */
-    withInvariantModules(modules: readonly ProjectModule[]): InvariantBuilder<ENTITIES, ALLOWED_ROOT_ENTITIES, $MAP, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ALIASES, ExpandAndMergeInvariants<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ALIASES, INVARIANTS, AliasedInvariants<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ALIASES, string>>>;
-    withInvariants<ALIASED_INVARIANTS extends AliasedInvariants<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ALIASES, string>>(aliasedInvariants: ALIASED_INVARIANTS): InvariantBuilder<ENTITIES, ALLOWED_ROOT_ENTITIES, $MAP, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ALIASES, ExpandAndMergeInvariants<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ALIASES, INVARIANTS, ALIASED_INVARIANTS>>;
-    /**
-     * DO NOT USE in runtime!
-     *
-     * This is just a dev-time to review conflicts in declared and actually reportable violations.
-     * Use your IDEs code-completion to see which entities have conflicts and which violations are the conflicting ones.
-     *
-     * Use the helper when you see the following error on the `.buildViolationExpressions()` method call:
-     * ```
-     * TS2349: This expression is not callable.
-     * Type never has no call signatures.
-     * ```
-     * simply
-     * ```ts
-     * const violationExpressions = invariantBuilder
-     *   .withInvariants(createBuiltinInvariants(domainComponentReader))
-     *   .withInvariants(kitchenRangeInvariants)
-     *   ._conflicts.Oven. // <- trigger code-completion here
-     * ```
-     */
-    _conflicts: ConflictingInvariants<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, DeclaredInvariants<ENTITIES, ALLOWED_ROOT_ENTITIES, $MAP, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA>, INVARIANTS>;
-    buildViolationExpressions: BuildViolationExpressions<ENTITIES, ALLOWED_ROOT_ENTITIES, $MAP, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, INVARIANTS>;
-}
-export {};

package/dist/domain/core/invariant/invariants.js

@@ -1 +1 @@
-import{SHARED_FOLDER_HINT as t,createContractError as e,isRecord as a}from"../../project-modules/index.js";import{expandAlias as i}from"../model/index.js";let r={expected:"an object of invariant lists keyed by entity type or alias",fix:`Create it with phx.domain.implementCustomInvariants({ ... }) (phx.domain.admin.implementCustomInvariants({ ... }) under src/admin/), ${t}.`},n=t=>a(t)&&"function"==typeof t.evaluate,s=t=>a(t)&&Object.values(t).every(t=>Array.isArray(t)&&t.every(n));export const resolveInvariantModules=t=>{let a={};for(let i of t){if(!s(i.exports))throw e(i.origin,r,i.exports);for(let[t,e]of Object.entries(i.exports))a[t]=[...a[t]??[],...e]}return a};export class InvariantBuilder{aliasMap;invariants;constructor(t,e={}){this.aliasMap=t,this.invariants=e}withInvariantModules(t){return this.withInvariants(resolveInvariantModules(t))}withInvariants(t){let e={...this.invariants};return Object.entries(t).forEach(([t,a])=>{i(this.aliasMap,t).forEach(t=>{e[t]=[...e[t]??[],...a]})}),new InvariantBuilder(this.aliasMap,e)}_conflicts={};buildViolationExpressions=()=>{let t={};return Object.entries(this.invariants).forEach(([e,a])=>{t[e]={$violations:{evaluate:(t,e,i)=>a.flatMap(a=>a.evaluate(t,e,i)),meta:{}}}}),t}}
+export{};

package/dist/domain/core/invariant/violation.d.ts

@@ -1,6 +1,6 @@
 import type { I18n } from '@lingui/core';
-import type { Localizable } from '@salsita-ai/common/utils';
-import type { StateEmission } from '../../domain-context/store-system/store-system.js';
+import { type Localizable } from '@salsita-ai/common/utils';
+import type { StateEmission } from '../emission/index.js';
 import type { $DomainEntity, DomainEntity, EntityId } from '../model/index.js';
 /**
  * An **ORDERED** list of violation severities.
@@ -66,7 +66,55 @@ export declare const ViolationSchema: {
             readonly enum: ("fatal" | "fixable" | "notice" | "warning")[];
         };
         readonly message: {
-            readonly type: 'string';
+            readonly anyOf: [{
+                readonly type: 'string';
+            }, {
+                readonly type: 'object';
+                readonly properties: {
+                    readonly id: {
+                        readonly type: 'string';
+                    };
+                    readonly comment: {
+                        readonly type: 'string';
+                    };
+                    readonly message: {
+                        readonly type: 'string';
+                    };
+                    readonly values: {
+                        readonly type: 'object';
+                        readonly additionalProperties: true;
+                    };
+                };
+                readonly required: ["id"];
+                readonly additionalProperties: false;
+                readonly import: [{
+                    readonly module: '@lingui/core';
+                    readonly member: 'MessageDescriptor';
+                }];
+                readonly tsType: 'MessageDescriptor';
+            }, {
+                readonly import: [{
+                    readonly module: '@salsita-ai/sdk/common/utils';
+                    readonly member: 'MultilingualString';
+                }];
+                readonly tsType: 'MultilingualString';
+                readonly type: 'object';
+                readonly properties: {
+                    readonly $lang: {
+                        readonly type: 'object';
+                        readonly additionalProperties: {
+                            readonly type: 'string';
+                        };
+                    };
+                };
+                readonly required: ["$lang"];
+                readonly additionalProperties: false;
+            }];
+            readonly tsType: 'Localizable';
+            readonly import: [{
+                readonly module: '@salsita-ai/sdk/common/utils';
+                readonly member: 'Localizable';
+            }];
         };
         readonly controlViolationPriority: {
             readonly type: 'number';

package/dist/domain/core/invariant/violation.js

@@ -1 +1 @@
-let e=["fatal","fixable","warning","notice"];export const compareSeverity=(t,i)=>e.indexOf(t)-e.indexOf(i);export const ViolationSchema={type:"object",properties:{type:{type:"string"},severity:{enum:e.slice()},message:{type:"string"},controlViolationPriority:{type:"number"}},required:["type","severity"],additionalProperties:!1};
+import{MessageDescriptorSchema as e,MultilingualStringSchema as t}from"@salsita-ai/common/utils";let i=["fatal","fixable","warning","notice"];export const compareSeverity=(e,t)=>i.indexOf(e)-i.indexOf(t);export const ViolationSchema={type:"object",properties:{type:{type:"string"},severity:{enum:i.slice()},message:{anyOf:[{type:"string"},e,t],tsType:"Localizable",import:[{module:"@salsita-ai/sdk/common/utils",member:"Localizable"}]},controlViolationPriority:{type:"number"}},required:["type","severity"],additionalProperties:!1};

package/dist/domain/core/model/model.d.ts

@@ -25,7 +25,7 @@ export declare const VirtualEntityIdSchema: {
 };
 export declare const createVirtualEntityId: (name: string) => VirtualEntityId;
 export declare const isVirtualEntityId: (value: EntityId<any>) => value is VirtualEntityId;
-export type DomainEntityId<TYPE extends string> = `${TYPE}-${number}` & {
+export type DomainEntityId<TYPE extends string = string> = `${TYPE}-${number}` & {
     __brand: TYPE;
 };
 /**

package/dist/domain/core/recipe/recipes.d.ts

@@ -1,55 +1,23 @@
-import type { OmitEmpty, OmitNever, UnionToIntersection } from '@salsita-ai/common/utils';
-import { type AliasMap, type DomainEntity, type DomainEntityId, type DomainEntityReflection, type EntityByType, type EventualAlias, type ExpandAlias, type ExtractFromAliasedRecord, type TypeOrAlias } from '../model/index.js';
-export type EntityDefaults<ENTITY extends DomainEntity<string>> = {
-    [K in Exclude<keyof ENTITY, 'id' | 'type'>]: ENTITY[K] extends DomainEntityId<any> ? null : ENTITY[K];
-};
+import { type AnyAliasMap, type DomainEntity, type DomainEntityReflection, type EntityByType } from '../model/index.js';
+/** The entity a recipe yields: a whole entity, which the recipe system gives a new id when it cooks the recipe. */
 export type EntityRecipe<ENTITY extends DomainEntity<string>> = ENTITY;
+/** What a project passes to its recipe factory: the entity type, and the properties that differ from the defaults. */
 export type EntityOverrides<ENTITIES extends DomainEntity<string>, TYPE extends ENTITIES['type']> = Partial<Omit<EntityByType<ENTITIES, TYPE>, 'type'>> & {
     type: TYPE;
 };
-export type DeclaredEntitiesDefaults<ENTITIES extends DomainEntity<string>> = {
-    [K in ENTITIES['type']]: EntityDefaults<EntityByType<ENTITIES, K>>;
-};
-type ExpandDefaults<ENTITIES extends DomainEntity<string>, ALIASES extends Readonly<Record<string, ENTITIES>>, ALIASED_DEFAULTS extends Partial<Record<TypeOrAlias<ENTITIES, ALIASES>, Record<string, unknown>>>> = {
-    [K in ENTITIES['type']]: ExtractFromAliasedRecord<ENTITIES, ALIASES, ALIASED_DEFAULTS, EventualAlias<ENTITIES, ALIASES, K> | K> extends infer DEFAULTS_FROM_ALIAS ? [
-        DEFAULTS_FROM_ALIAS
-    ] extends [never] ? Record<never, never> : unknown extends UnionToIntersection<DEFAULTS_FROM_ALIAS> ? never : UnionToIntersection<DEFAULTS_FROM_ALIAS> : never;
-};
-export type AliasedEntitiesDefaults<ENTITIES extends DomainEntity<string>, ALIASES extends Readonly<Record<string, ENTITIES>>> = {
-    [K in TypeOrAlias<ENTITIES, ALIASES>]?: Partial<EntityDefaults<ExpandAlias<ENTITIES, ALIASES, K>>>;
-};
+/** The function a project creates recipes with, `phx.domain.createRecipe`. */
 export type RecipeFactory<ENTITIES extends DomainEntity<string>> = <TYPE extends ENTITIES['type']>(overrides: EntityOverrides<ENTITIES, TYPE>) => EntityRecipe<EntityByType<ENTITIES, TYPE>>;
-type ConflictingDefaults<PROVIDED extends Record<string, Record<string, unknown>>, EXPECTED extends Record<string, Record<string, unknown>>> = OmitEmpty<OmitNever<{
-    [TYPE in keyof PROVIDED | keyof EXPECTED]: TYPE extends keyof EXPECTED ? TYPE extends keyof PROVIDED ? PROVIDED[TYPE] extends EXPECTED[TYPE] ? never : OmitNever<Exclude<EXPECTED[TYPE], PROVIDED[TYPE]>> : EXPECTED[TYPE] : never;
-}>>;
-type Build<ENTITIES extends DomainEntity<string>, PROVIDED extends Record<string, Record<string, unknown>>, EXPECTED extends Record<string, Record<string, unknown>>> = Record<string, never> extends ConflictingDefaults<PROVIDED, EXPECTED> ? {
-    build: () => RecipeFactory<ENTITIES>;
-} : {
-    /**
-     * DO NOT USE in runtime!
-     *
-     * This is just a dev-time tool to review which defaults you forgot to provide.
-     * Use your IDEs code-completion to see which entities have missing expressions
-     * and which expressions these are.
-     *
-     * Use the helper when you see the following error on the `.build()` method call:
-     * ```
-     * TS2349: This expression is not callable.
-     * Type never has no call signatures.
-     * ```
-     * simply
-     * ```ts
-     *   .withDefaults({...})
-     *   ._conflicts.Oven. // <- trigger code-completion here
-     * ```
-     */
-    _conflicts: ConflictingDefaults<PROVIDED, EXPECTED>;
-};
-export declare const RecipeFactoryBuilder: {
-    forAliases: <ENTITIES extends DomainEntity<string>, ALIASES extends Record<string, ENTITIES>>(aliasMap: AliasMap<ALIASES>) => {
-        forEntities: (entityReflections: ReadonlyArray<ENTITIES extends any ? DomainEntityReflection<ENTITIES> : never>) => {
-            withDefaults: <ALIASED_DEFAULTS extends AliasedEntitiesDefaults<ENTITIES, ALIASES>>(entitiesDefaults: ALIASED_DEFAULTS) => Build<ENTITIES, ExpandDefaults<ENTITIES, ALIASES, ALIASED_DEFAULTS>, DeclaredEntitiesDefaults<ENTITIES>>;
-        };
-    };
-};
-export {};
+/**
+ * Creates the recipe factory of a domain from the `defaults` of its spec.
+ *
+ * Defaults declared for an alias apply to every entity type of the alias, and a later key overrides
+ * an earlier one. The defaults of an entity type must be a whole entity of that type: they are
+ * validated here against the entity's schema, so a domain with invalid defaults fails when its
+ * module loads. An entity type without defaults is not checked.
+ *
+ * `ENTITIES` is the only type the result depends on, and no argument determines it, so the caller
+ * states it.
+ *
+ * @param defaults Property values by entity type or alias.
+ */
+export declare const createRecipeFactory: <ENTITIES extends DomainEntity<string>>(aliasMap: AnyAliasMap, entityReflections: ReadonlyArray<ENTITIES extends unknown ? DomainEntityReflection<ENTITIES> : never>, defaults: Readonly<Record<string, Readonly<Record<string, unknown>>>>) => RecipeFactory<ENTITIES>;

package/dist/domain/core/recipe/recipes.js

@@ -1 +1 @@
-import{_unsafeBuildDomainEntityId as e,expandAlias as r}from"../model/index.js";export const RecipeFactoryBuilder={forAliases:t=>({forEntities:o=>({withDefaults:i=>{let a={};Object.entries(i).forEach(([e,o])=>{r(t,e).forEach(e=>{a[e]={...a[e],...o}})});let n=new Map(o.map(e=>[e.type,e._meta.validator]));return Object.entries(a).forEach(([r,t])=>{let o=n.get(r);if(!o)throw Error(`Defaults provided for unknown entity ${r}`);if(!o({id:e(r,1),type:r,...t}))throw console.error(o.errors,t),Error(`Invalid defaults for ${r} entity.`)}),{build:()=>r=>({id:e(r.type,1),...a[r.type],...r})}}})})};
+import{_unsafeBuildDomainEntityId as e,expandAlias as r}from"../model/index.js";export const createRecipeFactory=(t,o,i)=>{let a={};Object.entries(i).forEach(([e,o])=>{r(t,e).forEach(e=>{a[e]={...a[e],...o}})});let n=new Map(o.map(e=>[e.type,e._meta.validator]));return Object.entries(a).forEach(([r,t])=>{let o=n.get(r);if(!o)throw Error(`Defaults provided for unknown entity ${r}`);if(!o({id:e(r,1),type:r,...t}))throw console.error(o.errors,t),Error(`Invalid defaults for ${r} entity.`)}),r=>({id:e(r.type,1),...a[r.type],...r})};

package/dist/domain/core/relation/all-of-type-relation.d.ts

@@ -1,32 +1,19 @@
 import type { ExpressionMeta } from '../expression/index.js';
-import { type AliasMap, type DomainEntity, type DomainEntityId, type TypeOrAlias } from '../model/index.js';
+import { type AnyAliasMap, type DomainEntity, type DomainEntityId } from '../model/index.js';
 import type { DomainState } from '../state/index.js';
-interface AllOfType0Relation<ENTITIES extends DomainEntity<string>, ALIASES extends Record<string, ENTITIES>, TARGET extends TypeOrAlias<ENTITIES, ALIASES>> {
+/** A relation whose related entities are all entities of the target type or alias. */
+export interface AllOfTypeRelation {
     kind: 'allOfType';
-    target: TARGET;
-    cardinality: '0-1';
+    target: string;
+    cardinality: '0-1' | '1-1' | '0-N' | '1-N';
     meta?: ExpressionMeta;
 }
-interface AllOfType1Relation<ENTITIES extends DomainEntity<string>, ALIASES extends Record<string, ENTITIES>, TARGET extends TypeOrAlias<ENTITIES, ALIASES>> {
-    kind: 'allOfType';
-    target: TARGET;
-    cardinality: '1-1';
-    meta?: ExpressionMeta;
-}
-interface AllOfTypeNRelation<ENTITIES extends DomainEntity<string>, ALIASES extends Record<string, ENTITIES>, TARGET extends TypeOrAlias<ENTITIES, ALIASES>> {
-    kind: 'allOfType';
-    target: TARGET;
-    cardinality: '0-N' | '1-N';
-    meta?: ExpressionMeta;
-}
-export type AllOfTypeRelation<ENTITIES extends DomainEntity<string>, ALIASES extends Record<string, ENTITIES>, TARGET extends TypeOrAlias<ENTITIES, ALIASES>> = AllOfType0Relation<ENTITIES, ALIASES, TARGET> | AllOfType1Relation<ENTITIES, ALIASES, TARGET> | AllOfTypeNRelation<ENTITIES, ALIASES, TARGET>;
 /**
  * Resolves `allOfType` relations from a per-state index. Relations targeting the same set of types
  * share one bucket; the first resolution on a state walks the entities once to fill every bucket,
  * and every later resolution on that state is a lookup. Registration closes once the first state
  * has been indexed, so a bucket can never be missing from an index that was already built.
  */
-export declare const createAllOfTypeRelation: <ENTITIES extends DomainEntity<string>, ALIASES extends Record<string, ENTITIES>>(aliasMap: AliasMap<ALIASES>) => (relation: {
-    readonly target: TypeOrAlias<ENTITIES, ALIASES>;
-}) => (_selfId: DomainEntityId<string>, state: DomainState<ENTITIES>) => DomainEntityId<string>[];
-export {};
+export declare const createAllOfTypeRelation: (aliasMap: AnyAliasMap) => (relation: {
+    readonly target: string;
+}) => (_selfId: DomainEntityId<string>, state: DomainState<DomainEntity<string>>) => DomainEntityId<string>[];

package/dist/domain/core/relation/all-of-type-relation.js

@@ -1 +1 @@
-import{expandAlias as e}from"../model/index.js";export const createAllOfTypeRelation=t=>{let r=new Map,a=new WeakMap,n=!1;return o=>{if(n)throw Error(`Cannot register all-of-type relation targeting ${String(o.target)} after evaluation started. Create all relation expressions before evaluating the domain state.`);let i=new Set(e(t,o.target)),l=[...i].sort().join("|");return r.set(l,i),(e,t)=>(e=>{let t=a.get(e);if(t)return t;n=!0;let o=new Map([...r.keys()].map(e=>[e,[]]));for(let t of e.entities)for(let[e,a]of r)a.has(t.type)&&o.get(e).push(t.id);return a.set(e,o),o})(t).get(l)}};
+import{expandAlias as e}from"../model/index.js";export const createAllOfTypeRelation=t=>{let r=new Map,a=new WeakMap,n=!1;return o=>{if(n)throw Error(`Cannot register all-of-type relation targeting ${o.target} after evaluation started. Create all relation expressions before evaluating the domain state.`);let l=new Set(e(t,o.target)),i=[...l].sort().join("|");return r.set(i,l),(e,t)=>(e=>{let t=a.get(e);if(t)return t;n=!0;let o=new Map([...r.keys()].map(e=>[e,[]]));for(let t of e.entities)for(let[e,a]of r)a.has(t.type)&&o.get(e).push(t.id);return a.set(e,o),o})(t).get(i)}};