@salsita-ai/sdk 0.50.0-develop.98e8b1502f → 0.50.0-develop.9feae4851f

package/dist/domain/{components → core/component}/updates.d.ts

@@ -1,12 +1,13 @@
 import type { Localizable } from '@salsita-ai/common/utils';
-import type { ComponentInstance, StateOfComponent, SystemComponentType, SystemComponentTypeConstraint, WritableStateOfComponent } from '../core/component.js';
-import type { DomainEntity, EntityByType, EntityId } from '../core/model.js';
+import type { ComponentInstance, DomainEntity, EntityByType, EntityId, StateOfComponent, SystemComponentType, SystemComponentTypeConstraint, WritableStateOfComponent } from '../model/index.js';
 import type { OneComponentFilter } from './component-reader-types.js';
 export interface ComponentModification<COMPONENT_TYPE extends SystemComponentTypeConstraint> {
     kind: 'modifyComponent';
     entityId: EntityId;
     updateTag: string;
     hint?: Localizable;
+    /** What the assistant agent is told about this update instead of `hint`; `null` keeps the wording from it, and its change record then explains the change by `updateTag`. Never shown to the user. */
+    agentHint?: string | null;
     componentInstance: ComponentInstance<COMPONENT_TYPE>;
     writableState: WritableStateOfComponent<COMPONENT_TYPE>;
     metadata?: Record<string, unknown>;
@@ -17,6 +18,8 @@ export interface EphemeralRecordModification<COMPONENT_TYPE extends SystemCompon
     entityId: EntityId;
     updateTag: string;
     hint?: Localizable;
+    /** What the assistant agent is told about this update instead of `hint`; `null` keeps the wording from it, and its change record then explains the change by `updateTag`. Never shown to the user. */
+    agentHint?: string | null;
     componentInstance: ComponentInstance<COMPONENT_TYPE>;
     writableState: WritableStateOfComponent<COMPONENT_TYPE>;
 }
@@ -25,6 +28,8 @@ export interface EphemeralRecordCreation<COMPONENT_TYPE extends SystemComponentT
     entityId: EntityId;
     updateTag: string;
     hint?: Localizable;
+    /** What the assistant agent is told about this update instead of `hint`; `null` keeps the wording from it, and its change record then explains the change by `updateTag`. Never shown to the user. */
+    agentHint?: string | null;
     componentInstance: ComponentInstance<COMPONENT_TYPE>;
     initialState: StateOfComponent<COMPONENT_TYPE>;
 }
@@ -34,6 +39,8 @@ export interface EphemeralRecordDeletion<COMPONENT_TYPE extends SystemComponentT
     componentInstance: ComponentInstance<COMPONENT_TYPE>;
     updateTag: string;
     hint?: Localizable;
+    /** What the assistant agent is told about this update instead of `hint`; `null` keeps the wording from it, and its change record then explains the change by `updateTag`. Never shown to the user. */
+    agentHint?: string | null;
 }
 export type DomainEntityStateDelta<ENTITY extends DomainEntity<string>> = Partial<Omit<ENTITY, 'id' | 'type'>>;
 export interface DomainEntityModification<ENTITY extends DomainEntity<string> = DomainEntity<string>> {
@@ -41,6 +48,8 @@ export interface DomainEntityModification<ENTITY extends DomainEntity<string> =
     entityId: ENTITY['id'];
     updateTag: string;
     hint?: Localizable;
+    /** What the assistant agent is told about this update instead of `hint`; `null` keeps the wording from it, and its change record then explains the change by `updateTag`. Never shown to the user. */
+    agentHint?: string | null;
     stateDelta: DomainEntityStateDelta<ENTITY>;
     origin?: ComponentModification<SystemComponentTypeConstraint>;
 }
@@ -55,6 +64,8 @@ export interface DomainEntityCreation<ENTITY extends DomainEntity<string>, PAREN
     collection?: string;
     parentId: PARENT['id'];
     hint?: Localizable;
+    /** What the assistant agent is told about this update instead of `hint`; `null` keeps the wording from it, and its change record then explains the change by `updateTag`. Never shown to the user. */
+    agentHint?: string | null;
 }
 export interface DomainEntityReplacement<ENTITY extends DomainEntity<string>> {
     kind: 'replaceDomainEntity';
@@ -63,12 +74,16 @@ export interface DomainEntityReplacement<ENTITY extends DomainEntity<string>> {
     updateTag: string;
     keepChildren: boolean;
     hint?: Localizable;
+    /** What the assistant agent is told about this update instead of `hint`; `null` keeps the wording from it, and its change record then explains the change by `updateTag`. Never shown to the user. */
+    agentHint?: string | null;
 }
 export interface EntityDeletion<ENTITY extends DomainEntity<string>> {
     kind: 'deleteEntity';
     entityId: EntityId<ENTITY>;
     updateTag: string;
     hint?: Localizable;
+    /** What the assistant agent is told about this update instead of `hint`; `null` keeps the wording from it, and its change record then explains the change by `updateTag`. Never shown to the user. */
+    agentHint?: string | null;
 }
 export type DataUpdate<ENTITY extends DomainEntity<string>, PARENT extends DomainEntity<string>> = EphemeralRecordModification | EphemeralRecordCreation | EphemeralRecordDeletion | DomainEntityModification<ENTITY> | DomainEntityCreation<ENTITY, PARENT> | DomainEntityReplacement<ENTITY> | EntityDeletion<ENTITY>;
 export type StateUpdate<ENTITY extends DomainEntity<string>, PARENT extends DomainEntity<string>> = ComponentModification<SystemComponentTypeConstraint> | DataUpdate<ENTITY, PARENT>;

package/dist/domain/{components → core/component}/view-state-component.d.ts

@@ -1,4 +1,4 @@
-import type { EntityId } from '../core/model.js';
+import { type EntityId } from '../model/index.js';
 export type ViewStateComponentState = {
     readonly activeState: string;
 };

package/dist/domain/core/component/view-state-component.js

@@ -0,0 +1 @@
+import{isSnapshotInstance as t}from"../model/index.js";import{SystemComponentBuilder as e}from"./system-component-builder.js";import{systemVirtualEntityId as o}from"./system-virtual-entity.js";export const viewStateComponent=e.component("viewState").withState({type:"object",properties:{activeState:{type:"string"}},required:["activeState"],additionalProperties:!1}).withWritableKeys(["activeState"]).build();export const isViewComponentSnapshot=e=>t(e,"singleton",viewStateComponent);export const isSystemViewComponentSnapshot=t(o,"singleton",viewStateComponent);

package/dist/domain/{components → core/component}/viewport-state-component.d.ts

@@ -1,4 +1,4 @@
-import type { EntityId } from '../core/model.js';
+import { type EntityId } from '../model/index.js';
 /**
  * A responsive class the configurator container currently satisfies. The values mirror the
  * responsive flags computed by the UI layer from the theme breakpoints (`isPhone`, `isMobile`,

package/dist/domain/core/component/viewport-state-component.js

@@ -0,0 +1 @@
+import{isSnapshotInstance as t}from"../model/index.js";import{SystemComponentBuilder as e}from"./system-component-builder.js";import{systemVirtualEntityId as o}from"./system-virtual-entity.js";export const VIEWPORTS=["phone","mobile","tablet","desktop","landscape","portrait"];export const viewportStateComponent=e.component("viewportState").withState({type:"object",properties:{active:{oneOf:[{type:"array",items:{type:"string",enum:[...VIEWPORTS]}},{type:"null"}]}},required:["active"],additionalProperties:!1,tsType:"ViewportStateComponentState",import:[{module:"@salsita-ai/sdk/domain",member:"ViewportStateComponentState"}]}).withWritableKeys(["active"]).build();export const isViewportStateComponentSnapshot=e=>t(e,"singleton",viewportStateComponent);export const isSystemViewportStateComponentSnapshot=t(o,"singleton",viewportStateComponent);

package/dist/domain/core/decoder/create-decoder.d.ts

@@ -0,0 +1,6 @@
+import type { Decoder } from './decoder.js';
+/**
+ * Creates the decoder of data that must match a JSON schema. `subject` is what the data is, as the
+ * error names it, for example `Session data`.
+ */
+export declare const createDecoder: <DATA>(schema: object, subject: string) => Decoder<DATA>;

package/dist/domain/core/decoder/create-decoder.js

@@ -0,0 +1 @@
+import{extendedSchemaValidator as r}from"../schema/index.js";export const createDecoder=(e,o)=>t=>{let i=r.compile(e);if(!i(t))throw Error(`${o} is not valid: ${r.errorsText(i.errors)}`);return t};

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

@@ -0,0 +1,6 @@
+/**
+ * Turns data of unknown shape into data of a known type, and throws when the data does not match.
+ * Everything that enters a domain from outside goes through one: published, session, frontend and
+ * backend data.
+ */
+export type Decoder<DATA> = (data: unknown) => DATA;

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

@@ -0,0 +1,2 @@
+export { createDecoder } from './create-decoder.js';
+export type { Decoder } from './decoder.js';

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

@@ -0,0 +1 @@
+export{createDecoder}from"./create-decoder.js";

package/dist/domain/core/domain-factory.d.ts

@@ -1,9 +1,8 @@
 import type { ExtendedJsonSchema } from '@salsita-ai/common/utils';
-import type { ActionDefinitions, AnyActionImplementations } from './action.js';
-import type { Expression } from './expression.js';
-import type { MigrateFunction } from './migrations.js';
-import type { $DomainEntity, DomainEntity, EntityByType } from './model.js';
-import type { $DomainEntityReflection, EntityReflections, SchemaOfObject } from './reflection.js';
+import type { ActionDefinitions, AnyActionImplementations } from './action/index.js';
+import type { Expression } from './expression/index.js';
+import type { $DomainEntity, $DomainEntityReflection, DomainEntity, EntityByType, EntityReflections, SchemaOfObject } from './model/index.js';
+import type { MigrateFunction } from './state/index.js';
 type $EntityReflections<ENTITIES extends DomainEntity<string>> = {
     [TYPE in ENTITIES['type']]: $DomainEntityReflection<$DomainEntity<EntityByType<ENTITIES, TYPE>>>;
 };

package/dist/domain/core/domain-factory.js

@@ -1 +1 @@
-import{migrateCommonAdminDomain as t}from"../admin-domain/implementation/common-admin-migrations.js";import{extendedSchemaValidator as r}from"./json-schema.js";export class DomainFactory{context;modelVersion;hasBackendData;constructor(t){this.context=t,this.modelVersion=t.modelVersion,this.hasBackendData=void 0!==t.backendData}parsePublishedData=t=>{let e=r.compile(this.context.publishedData);if(!e(t))throw Error(`Admin data is not valid: ${r.errorsText(e.errors)}`);return t};parseSessionData=t=>{let e=r.compile(this.context.sessionData);if(!e(t))throw Error(`Session data is not valid: ${r.errorsText(e.errors)}`);return t};parseFrontendData=t=>{let e=r.compile(this.context.frontendData);if(!e(t))throw Error(`Frontend data is not valid: ${r.errorsText(e.errors)}`);return t};parseBackendData=t=>{if(void 0===this.context.backendData)throw Error("Backend data is not supported for this domain");let e=r.compile(this.context.backendData);if(!e(t))throw Error(`Backend data is not valid: ${r.errorsText(e.errors)}`);return t};validateAndMigrateState=(r,e)=>{let a=this.context.isAdminDomain?t(r):r;return this.context.migrate({state:a,version:e},{trimExtraProperties:!1})}}
+import{migrateCommonAdminDomain as t}from"../admin-domain/implementation/common-admin-migrations.js";import{createDecoder as a}from"./decoder/index.js";export class DomainFactory{context;modelVersion;hasBackendData;constructor(t){this.context=t,this.modelVersion=t.modelVersion,this.hasBackendData=void 0!==t.backendData}parsePublishedData=t=>a(this.context.publishedData,"Admin data")(t);parseSessionData=t=>a(this.context.sessionData,"Session data")(t);parseFrontendData=t=>a(this.context.frontendData,"Frontend data")(t);parseBackendData=t=>{if(void 0===this.context.backendData)throw Error("Backend data is not supported for this domain");return a(this.context.backendData,"Backend data")(t)};validateAndMigrateState=(a,e)=>{let n=this.context.isAdminDomain?t(a):a;return this.context.migrate({state:n,version:e},{trimExtraProperties:!1})}}

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

@@ -1,7 +1,6 @@
-import type { AnyExpressions, ExpressionContext } from './expression.js';
-import { type $DomainEntity, type DomainEntity, type DomainEntityId, type EntityByType } from './model.js';
-import type { AnyEntityReflections } from './reflection.js';
-import type { DomainState } from './state.js';
+import type { AnyExpressions, ExpressionContext } from './expression/index.js';
+import { type $DomainEntity, type AnyEntityReflections, type DomainEntity, type DomainEntityId, type EntityByType } from './model/index.js';
+import type { DomainState } from './state/index.js';
 export type AllowedRootEntityTypes<ALLOWED_ROOT_ENTITIES extends DomainEntity<string>> = ReadonlyArray<ALLOWED_ROOT_ENTITIES['type']>;
 export type AnyAllowedRootEntityTypes = AllowedRootEntityTypes<DomainEntity<string>>;
 /**

package/dist/domain/core/domain.js

@@ -1 +1 @@
-import{createCacheToken as t,getStickyCache as e}from"@salsita-ai/common/utils";import{domainEntityTypeFromId as i}from"./model.js";let r=t(),o=t();export class Domain{_context;constructor(t){this._context=t}getEntity=(t,i)=>{let r=e(i,o),n=r.get("entityMap");if(n)return n.get(t);let s=(t=>{let e=new Map;for(let i of t){if(e.has(i.id))throw Error(`Error while creating a UniqueEntityMap for caching of domain queries. Duplicate entity id ${i.id} encountered!`);e.set(i.id,i)}return e})(i.entities);return r.put("entityMap",s),s.get(t)};get$Entity=(t,i)=>{let o=e(i,r),n=o.get(t);if(n)return n;let s=this.getEntity(t,i);if(!s)throw Error(`Entity ${t} does not exist`);let a={...s},l=this._context.selectors.getDomainExpressions()[s.type];return l&&Object.entries(l).forEach(([t,e])=>{Object.defineProperty(a,t,{enumerable:!0,get:()=>e.evaluate(s.id,i,this._context.selectors.getExpressionContext())})}),Object.defineProperty(a,"_raw",{enumerable:!0,writable:!1,value:s}),Object.defineProperty(a,"_state",{enumerable:!0,writable:!1,value:i}),o.put(t,a),a};get$Entities=(t,e)=>t.map(t=>this.get$Entity(t,e));getRoot$Entity=t=>this.get$Entity(t.rootEntityId,t);validateExpressions=t=>{if(!this._context.selectors.getAllowedRootEntityTypes().includes(t.rootEntityType))throw Error(`Entity type ${t.rootEntityType} is not allowed as root entity`);if(!this.getEntity(t.rootEntityId,t))throw Error(`Root entity ${t.rootEntityId} was not found!`);t.entities.forEach(e=>{let i=this._context.selectors.getDomainExpressions()[e.type];void 0!==i&&Object.values(i).forEach(i=>{!0===i.meta.alwaysEvaluate&&i.evaluate(e.id,t,this._context.selectors.getExpressionContext())})})};validateEntity=t=>{let e=this._context.selectors.getEntityReflections()[t.type];if(!e)throw Error(`Unknown entity type ${t.type}`);return e._meta.validator(t)?{success:!0}:{success:!1,errors:e._meta.validator.errors?.map(t=>`${t.instancePath} ${t.message}`.trim())??[]}};getWritableEntityKeys=(t,e)=>{let r=i(t),o=this._context.selectors.getDomainExpressions()[r];return e.filter(t=>"id"!==t&&"type"!==t&&"_raw"!==t&&o?.[t]===void 0)}}
+import{createCacheToken as t,getStickyCache as e}from"@salsita-ai/common/utils";import{domainEntityTypeFromId as i}from"./model/index.js";let r=t(),o=t();export class Domain{_context;constructor(t){this._context=t}getEntity=(t,i)=>{let r=e(i,o),n=r.get("entityMap");if(n)return n.get(t);let s=(t=>{let e=new Map;for(let i of t){if(e.has(i.id))throw Error(`Error while creating a UniqueEntityMap for caching of domain queries. Duplicate entity id ${i.id} encountered!`);e.set(i.id,i)}return e})(i.entities);return r.put("entityMap",s),s.get(t)};get$Entity=(t,i)=>{let o=e(i,r),n=o.get(t);if(n)return n;let s=this.getEntity(t,i);if(!s)throw Error(`Entity ${t} does not exist`);let a={...s},l=this._context.selectors.getDomainExpressions()[s.type];return l&&Object.entries(l).forEach(([t,e])=>{Object.defineProperty(a,t,{enumerable:!0,get:()=>e.evaluate(s.id,i,this._context.selectors.getExpressionContext())})}),Object.defineProperty(a,"_raw",{enumerable:!0,writable:!1,value:s}),Object.defineProperty(a,"_state",{enumerable:!0,writable:!1,value:i}),o.put(t,a),a};get$Entities=(t,e)=>t.map(t=>this.get$Entity(t,e));getRoot$Entity=t=>this.get$Entity(t.rootEntityId,t);validateExpressions=t=>{if(!this._context.selectors.getAllowedRootEntityTypes().includes(t.rootEntityType))throw Error(`Entity type ${t.rootEntityType} is not allowed as root entity`);if(!this.getEntity(t.rootEntityId,t))throw Error(`Root entity ${t.rootEntityId} was not found!`);t.entities.forEach(e=>{let i=this._context.selectors.getDomainExpressions()[e.type];void 0!==i&&Object.values(i).forEach(i=>{!0===i.meta.alwaysEvaluate&&i.evaluate(e.id,t,this._context.selectors.getExpressionContext())})})};validateEntity=t=>{let e=this._context.selectors.getEntityReflections()[t.type];if(!e)throw Error(`Unknown entity type ${t.type}`);return e._meta.validator(t)?{success:!0}:{success:!1,errors:e._meta.validator.errors?.map(t=>`${t.instancePath} ${t.message}`.trim())??[]}};getWritableEntityKeys=(t,e)=>{let r=i(t),o=this._context.selectors.getDomainExpressions()[r];return e.filter(t=>"id"!==t&&"type"!==t&&"_raw"!==t&&o?.[t]===void 0)}}

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

@@ -0,0 +1,10 @@
+import type { DomainEntity, ExpandAlias, TypeOrAlias } from '../model/index.js';
+import type { AnonymousExpression } from './expression.js';
+/**
+ * The expressions a project implements, keyed by entity type or alias and then by expression name.
+ * 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>>;
+};

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

@@ -1,6 +1,5 @@
-import type { ExpandAlias, TypeOrAlias } from '../core/alias.js';
-import type { AnonymousExpression, ExpressionMetas } from '../core/expression.js';
-import type { DomainEntity } from '../core/model.js';
+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]>;

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

@@ -0,0 +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}]]);

package/dist/domain/{expressions → core/expression}/custom-expression.d.ts

@@ -1,8 +1,7 @@
-import type { TypeOrAlias } from '../core/alias.js';
-import type { AnonymousExpression, ExpressionContext, ExpressionMeta, ExpressionMetas } from '../core/expression.js';
-import type { $DomainEntity, DomainEntity, EntityByType } from '../core/model.js';
-import type { DomainState } from '../core/state.js';
-import type { AliasedExpressions } from '../domain-builder.js';
+import type { $DomainEntity, DomainEntity, EntityByType, 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>> = {
     [TYPE_OR_ALIAS in keyof $MAP]?: {

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

@@ -0,0 +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});

package/dist/domain/core/{expression.d.ts → expression/expression.d.ts}

@@ -1,12 +1,10 @@
 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 { TypeOrAlias } from './alias.js';
-import type { Domain } from './domain.js';
-import type { MigrateFunction } from './migrations.js';
-import type { $DomainEntity, DomainEntity } from './model.js';
-import type { DomainState } from './state.js';
+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 { 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>> {
     readonly mode: 'owner' | 'read' | 'finalize';
     readonly role: SessionRole;

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

@@ -0,0 +1,4 @@
+export type * from './aliased-expressions.js';
+export * from './constant-expressions.js';
+export * from './custom-expression.js';
+export type * from './expression.js';

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

@@ -0,0 +1 @@
+export*from"./constant-expressions.js";export*from"./custom-expression.js";

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

@@ -1,18 +1,12 @@
-export type { EnhancedJsonObjectSchemaType, EnhancedJsonSchemaType, JsonSchemaType, MemberImport, } from './enhanced-json-schema.js';
-export type { ActionContext, ActionDefinition, ActionDefinitions, ActionImplementation, ActionImplementations, ActionStateChange, ActionTypes, AnyActionContext, AnyActionImplementation, AnyActionImplementations, PreparedAction, } from './action.js';
-export { extendedSchemaValidator, getExtendedSchemaValidator } from './json-schema.js';
-export { _unsafeBuildDomainEntityId, domainEntityTypeFromId, createVirtualEntityId, isDomainEntityId, isVirtualEntityId, VirtualEntityIdSchema, isEqualEntityTypeAndId, parseDomainEntityId, DomainEntityIdSchema, DomainEntitySchema, $DomainEntitySchema, } from './model.js';
-export type { $DomainEntity, DomainEntity, VirtualEntityId, DomainEntityId, EntityIdSchema, EntityByType, EntityId, } from './model.js';
-export type { PartialSchemaOfObject, SchemaOfObject, EnumLike, EntityReflections } from './reflection.js';
-export { type Migration, MigrateFunctionBuilder, type MigrateFunction, type VersionedState, type MigrateFunctionOptions, type AnyVersionedState, StateMigrationError, isStateMigrationError, } from './migrations.js';
-export * from './reflection.js';
-export type { ComponentInstance, StateOfComponent, WritableStateOfComponent, SystemComponentType, SystemComponentTypeConstraint, ComponentSnapshot, } from './component.js';
-export { isEqualComponentInstance, areEqualComponentSnapshots, isEqualComponentSnapshot, isSnapshotOfComponentType, isInstanceOfComponentType, getComponentInstanceKey, getComponentSnapshotKey, } from './component.js';
-export { type DomainState, type DomainStateFactory, createInitialDomainState } from './state.js';
-export type * from './expression.js';
-export * from './alias.js';
-export * from './domain.js';
+export * from './action/index.js';
+export * from './component/index.js';
+export * from './decoder/index.js';
 export * from './domain-factory.js';
-export * from './preset.js';
-export { getCommonPhxDefinitions, availableDefinitions } from './common-definitions.js';
-export type { PhxValidateFunction, PhxValidationError, SchemaValidator } from './schema-validator.js';
+export * from './domain.js';
+export * from './expression/index.js';
+export * from './invariant/index.js';
+export * from './model/index.js';
+export * from './recipe/index.js';
+export * from './relation/index.js';
+export * from './schema/index.js';
+export * from './state/index.js';

package/dist/domain/core/index.js

@@ -1 +1 @@
-export{extendedSchemaValidator,getExtendedSchemaValidator}from"./json-schema.js";export{_unsafeBuildDomainEntityId,domainEntityTypeFromId,createVirtualEntityId,isDomainEntityId,isVirtualEntityId,VirtualEntityIdSchema,isEqualEntityTypeAndId,parseDomainEntityId,DomainEntityIdSchema,DomainEntitySchema,$DomainEntitySchema}from"./model.js";export{MigrateFunctionBuilder,StateMigrationError,isStateMigrationError}from"./migrations.js";export*from"./reflection.js";export{isEqualComponentInstance,areEqualComponentSnapshots,isEqualComponentSnapshot,isSnapshotOfComponentType,isInstanceOfComponentType,getComponentInstanceKey,getComponentSnapshotKey}from"./component.js";export{createInitialDomainState}from"./state.js";export*from"./alias.js";export*from"./domain.js";export*from"./domain-factory.js";export*from"./preset.js";export{getCommonPhxDefinitions,availableDefinitions}from"./common-definitions.js";
+export*from"./action/index.js";export*from"./component/index.js";export*from"./decoder/index.js";export*from"./domain-factory.js";export*from"./domain.js";export*from"./expression/index.js";export*from"./invariant/index.js";export*from"./model/index.js";export*from"./recipe/index.js";export*from"./relation/index.js";export*from"./schema/index.js";export*from"./state/index.js";

package/dist/domain/{invariants → core/invariant}/builtin-invariant.d.ts

@@ -1,5 +1,5 @@
-import type { DomainEntity, DomainEntityId } from '../core/model.js';
-import type { DomainState } from '../core/state.js';
+import type { DomainEntity, DomainEntityId } from '../model/index.js';
+import type { DomainState } from '../state/index.js';
 import type { Invariant } from './invariants.js';
 import type { Violation } from './violation.js';
 export declare const createInvariant: <VIOLATION_TYPE extends string>(evaluate: (selfId: DomainEntityId<string>, state: DomainState<DomainEntity<string>>) => ReadonlyArray<Violation<VIOLATION_TYPE>>) => Invariant<DomainEntity<string>, DomainEntity<string>, Record<string, unknown>, Record<string, unknown>, Record<string, unknown>, DomainEntity<string>, VIOLATION_TYPE>;

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

@@ -1,7 +1,6 @@
 import type { OmitEmpty, OmitNever } from '@salsita-ai/common/utils';
-import type { ExpandAlias, TypeOrAlias } from '../core/alias.js';
-import type { $DomainEntity, DomainEntity } from '../core/model.js';
-import type { CustomExpression } from '../expressions/custom-expression.js';
+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 { 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>>>> = {

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

@@ -0,0 +1 @@
+import{withProfilerLabel as t}from"../../utils/profiler-label.js";export const createCustomInvariantFactory=()=>e=>r=>{let n={};return Object.entries(r).forEach(([r,o])=>{let a=Object.entries(o).map(([n,o])=>({evaluate:t(`${r}_invariant_${n}`,(t,a,i)=>{let l=o(i.domain.get$Entity(t,a),a,i);if("boolean"==typeof l){let t=e[r]?.[n];if(!t)throw Error(`Cannot find statically defined violation for ${r}.${n}`);return l?[]:[t]}return l})}));n[r]=a}),n};

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

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

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

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

package/dist/domain/{invariants → core/invariant}/invariants.d.ts

@@ -1,8 +1,8 @@
 import type { OmitNever } from '@salsita-ai/common/utils';
-import { type AliasMap, type EventualAlias, type ExpandAlias, type ExtractFromAliasedRecord, type TypeOrAlias } from '../core/alias.js';
-import type { AnonymousExpression, ExpressionContext } from '../core/expression.js';
-import type { $DomainEntity, DomainEntity, EntityByType } from '../core/model.js';
-import type { DomainState } from '../core/state.js';
+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 { 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>>;
@@ -38,10 +38,18 @@ type ExpressionsFromInvariants<ENTITIES extends DomainEntity<string>, ALLOWED_RO
     };
 };
 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!

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

@@ -0,0 +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}}

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

@@ -0,0 +1 @@
+import{SystemComponentBuilder as o}from"../component/index.js";import{ViolationSchema as t}from"./violation.js";export const violationsComponent=o.component("violations").withState({tsType:"ViolationComponentState",type:"object",properties:{violations:{type:"array",items:t}},required:["violations"],additionalProperties:!1}).build();

package/dist/domain/{invariants → core/invariant}/violation.d.ts

@@ -1,7 +1,7 @@
 import type { I18n } from '@lingui/core';
 import type { Localizable } from '@salsita-ai/common/utils';
-import type { $DomainEntity, DomainEntity, EntityId } from '../core/model.js';
-import type { StateEmission } from '../domain-context/store-system/store-system.js';
+import type { StateEmission } from '../../domain-context/store-system/store-system.js';
+import type { $DomainEntity, DomainEntity, EntityId } from '../model/index.js';
 /**
  * An **ORDERED** list of violation severities.
  * Do not change the order of the items in this list.

package/dist/domain/core/{component.d.ts → model/component.d.ts}

@@ -1,6 +1,6 @@
 import { type ExtendedJsonSchema } from '@salsita-ai/common/utils';
+import type { PhxValidateFunction } from '../schema/index.js';
 import type { EntityId } from './model.js';
-import type { PhxValidateFunction } from './schema-validator.js';
 /**
  * Definition of how the component looks like, it's name, state and other properties. It is used to instantiate components.
  */

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

@@ -0,0 +1,6 @@
+export * from './alias.js';
+export * from './common-definitions.js';
+export * from './component.js';
+export * from './model.js';
+export * from './preset.js';
+export * from './reflection.js';

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

@@ -0,0 +1 @@
+export*from"./alias.js";export*from"./common-definitions.js";export*from"./component.js";export*from"./model.js";export*from"./preset.js";export*from"./reflection.js";

package/dist/domain/core/{reflection.d.ts → model/reflection.d.ts}

@@ -1,6 +1,6 @@
 import type { ExtendedJsonSchema } from '@salsita-ai/common/utils';
+import { type PhxValidateFunction } from '../schema/index.js';
 import { type $DomainEntity, type DomainEntity, type EntityByType, type EntityId } from './model.js';
-import type { PhxValidateFunction } from './schema-validator.js';
 type RequiredKeys<T> = {
     [K in keyof T]: undefined extends T[K] ? never : K;
 }[keyof T];

package/dist/domain/core/model/reflection.js

@@ -0,0 +1 @@
+import{extendedSchemaValidator as t}from"../schema/index.js";import{domainEntityTypeFromId as e,isDomainEntityId as s}from"./model.js";export class SchemaReflection{_meta;constructor(e,s){this._meta={name:e,schema:s,validator:t.compile(s)}}is=t=>this._meta.validator(t);assert(t){if(!this._meta.validator(t))throw Error(`Expected value to match schema of '${this._meta.name}' but got ${t}`)}}export class EnumReflection extends SchemaReflection{constructor(t,e){for(let s of(super(t,e),e.enum))Object.defineProperty(this,s,{value:s,writable:!1,enumerable:!0,configurable:!1})}values=()=>this._meta.schema.enum}let o=class BaseDomainEntityReflection{type;constructor(t){this.type=t}is=t=>t.type===this.type;assert(t){if(!this.is(t))throw Error(`Expected entity #${t.id} to be of type ${this.type} but got ${t.type}`)}isId=t=>s(t)&&e(t)===this.type;assertId(t){if(!this.isId(t))throw Error(`Expected entity id to be of type ${this.type} but got ${t}`)}assertIds(t){t.forEach(t=>{this.assertId(t)})}};export class DomainEntityReflection extends o{_meta;constructor(e,s){super(e);let o=s.reduce((t,e)=>{let s=e.$defs;return"object"==typeof s&&null!==s&&Object.assign(t,s),t},{}),r={type:"object",properties:{id:{type:"string",pattern:`^${e}-[0-9]+$`},type:{type:"string",const:e},...s.reduce((t,e)=>({...t,...e.properties}),{})},required:["id","type",...s.flatMap(t=>t.required??[])],additionalProperties:!1},i={...r,$defs:o};this._meta={name:e,schema:r,validator:t.compile(i)}}}let r=class $DomainEntityReflectionClass extends o{expressions;constructor(t,e,s){super(t),this.expressions=e,Object.assign(this,s)}};export const $DomainEntityReflection=r;let i=class BaseAliasReflection{name;types;typeSet;constructor(t,e){this.name=t,this.types=e,this.typeSet=new Set(e)}is=t=>this.typeSet.has(t.type);assert(t){if(!this.is(t))throw Error(`Expected entity #${t.id} to be a member of alias ${this.name} but got ${t.type}`)}isId=t=>s(t)&&this.typeSet.has(e(t));assertId(t){if(!this.isId(t))throw Error(`Expected entity id to be of a member of alias ${this.name} but got ${t}`)}assertIds(t){t.forEach(t=>{this.assertId(t)})}};export class RawAliasReflection extends i{reflections;constructor(t,e){super(t,e.map(t=>t.type)),this.reflections=e}}let a=class EnhancedAliasReflectionClass extends i{constructor(t,e,s){super(t,e),Object.assign(this,s)}};export const EnhancedAliasReflection=a;export function assertString(t){if("string"!=typeof t)throw Error(`Expected value to be a string but got ${t}`)}export function assertNumber(t){if("number"!=typeof t)throw Error(`Expected value to be a number but got ${t}`)}export function assertBoolean(t){if("boolean"!=typeof t)throw Error(`Expected value to be a boolean but got ${t}`)}

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

@@ -0,0 +1 @@
+export * from './recipes.js';

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

@@ -0,0 +1 @@
+export*from"./recipes.js";

package/dist/domain/{domain-context/recipe-system → core/recipe}/recipes.d.ts

@@ -1,7 +1,5 @@
 import type { OmitEmpty, OmitNever, UnionToIntersection } from '@salsita-ai/common/utils';
-import { type AliasMap, type EventualAlias, type ExpandAlias, type ExtractFromAliasedRecord, type TypeOrAlias } from '../../core/alias.js';
-import { type DomainEntity, type DomainEntityId, type EntityByType } from '../../core/model.js';
-import type { DomainEntityReflection } from '../../core/reflection.js';
+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];
 };

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

@@ -0,0 +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})}}})})};

package/dist/domain/{relations → core/relation}/all-of-type-relation.d.ts

@@ -1,7 +1,6 @@
-import { type AliasMap, type TypeOrAlias } from '../core/alias.js';
-import type { ExpressionMeta } from '../core/expression.js';
-import type { DomainEntity, DomainEntityId } from '../core/model.js';
-import type { DomainState } from '../core/state.js';
+import type { ExpressionMeta } from '../expression/index.js';
+import { type AliasMap, type DomainEntity, type DomainEntityId, type TypeOrAlias } 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>> {
     kind: 'allOfType';
     target: TARGET;

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

@@ -0,0 +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)}};

package/dist/domain/{relations → core/relation}/component-factories.d.ts

@@ -1,5 +1,4 @@
-import type { DomainEntity, DomainEntityId } from '../core/model.js';
-import type { DomainEntityReflection, RawAliasReflection } from '../core/reflection.js';
+import type { DomainEntity, DomainEntityId, DomainEntityReflection, RawAliasReflection } from '../model/index.js';
 import type { ComposedOfComponentState } from './composed-of.js';
 import type { ReferenceComponentState } from './reference-component.js';
 export declare const createSingleReferenceRead: <TARGET extends DomainEntity<string>>(_targetReflection: DomainEntityReflection<TARGET> | RawAliasReflection<TARGET>, field: string) => (self: object, state: unknown, ctx: unknown) => ReferenceComponentState;

package/dist/domain/core/relation/component-factories.js

@@ -0,0 +1 @@
+import{memoEval as e}from"../../utils/memo-eval.js";export const createSingleReferenceRead=(t,r)=>e(e=>[e[r]],e=>({referencedEntityIds:null===e?[]:[e]}));export const createSingleReferenceWrite=(e,t)=>r=>{let n=r.referencedEntityIds[0];return n&&e.assertId(n),{[t]:n??null}};export const createMultipleReferenceRead=(t,r)=>e(e=>[e[r]],e=>({referencedEntityIds:e}));export const createMultipleReferenceWrite=(e,t)=>r=>(e.assertIds(r.referencedEntityIds),{[t]:r.referencedEntityIds});export const createSingleCompositionRead=t=>e(e=>[e[t]?.id??null],e=>({childEntityIds:null===e?[]:[e]}));export const createMultipleCompositionRead=t=>e(e=>e[t].map(e=>e.id),(...e)=>({childEntityIds:e}));export const createEmptyWrite=()=>()=>({});

package/dist/domain/{relations → core/relation}/composed-of.d.ts

@@ -1,4 +1,4 @@
-import { type DomainEntityId } from '../core/model.js';
+import { type DomainEntityId } from '../model/index.js';
 export type ComposedOfComponentState = {
     /**
      * List of entity IDs that the parent entity is composed of

package/dist/domain/core/relation/composed-of.js

@@ -0,0 +1 @@
+import{SystemComponentBuilder as o}from"../component/index.js";import{EntityIdSchema as t}from"../model/index.js";export const composedOfComponent=o.component("composedOf").withState({type:"object",properties:{childEntityIds:{type:"array",items:t}},required:["childEntityIds"],additionalProperties:!1}).build();

package/dist/domain/{relations → core/relation}/direct-relation.d.ts

@@ -1,6 +1,5 @@
-import type { ExpandAlias, TypeOrAlias } from '../core/alias.js';
-import type { ExpressionMeta } from '../core/expression.js';
-import type { DomainEntity } from '../core/model.js';
+import type { ExpressionMeta } from '../expression/index.js';
+import type { DomainEntity, ExpandAlias, TypeOrAlias } from '../model/index.js';
 import type { ArrayReferenceField, SingleReferenceField } from './reference-field.js';
 import type { RelationImplementation } from './relation-implementation.js';
 interface DirectArrayRelation<ENTITIES extends DomainEntity<string>, ALIASES extends Record<string, ENTITIES>, SELF extends TypeOrAlias<ENTITIES, ALIASES>, TARGET extends TypeOrAlias<ENTITIES, ALIASES>> {

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

@@ -0,0 +1,9 @@
+export * from './all-of-type-relation.js';
+export * from './component-factories.js';
+export * from './composed-of.js';
+export * from './direct-relation.js';
+export * from './indirect-relation.js';
+export * from './reference-component.js';
+export type * from './reference-field.js';
+export * from './relation-factory.js';
+export type * from './relation-implementation.js';

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

@@ -0,0 +1 @@
+export*from"./all-of-type-relation.js";export*from"./component-factories.js";export*from"./composed-of.js";export*from"./direct-relation.js";export*from"./indirect-relation.js";export*from"./reference-component.js";export*from"./relation-factory.js";

package/dist/domain/{relations → core/relation}/indirect-relation.d.ts

@@ -1,7 +1,6 @@
-import { type AliasMap, type ExpandAlias, type TypeOrAlias } from '../core/alias.js';
-import type { ExpressionMeta } from '../core/expression.js';
-import { type DomainEntity, type DomainEntityId } from '../core/model.js';
-import type { DomainState } from '../core/state.js';
+import type { ExpressionMeta } from '../expression/index.js';
+import { type AliasMap, type DomainEntity, type DomainEntityId, type ExpandAlias, type TypeOrAlias } from '../model/index.js';
+import type { DomainState } from '../state/index.js';
 import type { ArrayReferenceField, SingleReferenceField } from './reference-field.js';
 interface IndirectNullableSingle0Relation<ENTITIES extends DomainEntity<string>, ALIASES extends Record<string, ENTITIES>, SELF extends TypeOrAlias<ENTITIES, ALIASES>, TARGET extends TypeOrAlias<ENTITIES, ALIASES>> {
     kind: 'indirect';

package/dist/domain/core/relation/indirect-relation.js

@@ -0,0 +1 @@
+import{isArray as e}from"@salsita-ai/common/utils";import{expandAlias as t}from"../model/index.js";let r=e=>"string"==typeof e;export const createIndirectRelation=i=>{let n=new Map,o=new WeakMap,a=!1;return l=>{if(a)throw Error(`Cannot register indirect relation ${String(l.target)}#${l.field} after evaluation started. Create all relation expressions before evaluating the domain state.`);let s=new Set(t(i,l.target)),f=`${l.field}|${[...s].sort().join("|")}`;return n.set(f,{field:l.field,targetTypes:s}),(t,i)=>(t=>{let i=o.get(t);if(i)return i;a=!0;let l=new Map([...n.keys()].map(e=>[e,new Map]));for(let i of t.entities)for(let[t,{field:o,targetTypes:a}]of n){if(!a.has(i.type))continue;let n=i[o],s=e(n)?new Set(n.filter(r)):r(n)?[n]:[],f=l.get(t);for(let e of s){let t=f.get(e);t||(t=[],f.set(e,t)),t.push(i.id)}}return o.set(t,l),l})(i).get(f).get(t)??[]}};

package/dist/domain/{relations → core/relation}/reference-component.d.ts

@@ -1,6 +1,5 @@
-import type { DomainComponentOpticBuilder } from '../components/domain-component-optic.js';
-import type { $DomainEntity, DomainEntity, DomainEntityId } from '../core/model.js';
-import type { DomainEntityReflection, RawAliasReflection } from '../core/reflection.js';
+import { type DomainComponentOpticBuilder } from '../component/index.js';
+import { type $DomainEntity, type DomainEntity, type DomainEntityId, type DomainEntityReflection, type RawAliasReflection } from '../model/index.js';
 import type { ArrayReferenceField, SingleReferenceField } from './reference-field.js';
 export type ReferenceComponentState = {
     /**
@@ -14,5 +13,5 @@ export type ReferenceComponentState = {
  */
 export declare const referenceComponent: import("../index.js").SystemComponentType<"reference", ReferenceComponentState, "referencedEntityIds">;
 export type ReferenceComponent = typeof referenceComponent;
-export declare const attachSingleReferenceComponent: <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>, ENTITY extends ENTITIES, $ENTITY extends $DomainEntity<ENTITY>, TARGET_ENTITY extends ENTITIES>(attachComponent: DomainComponentOpticBuilder<ENTITIES, ALLOWED_ROOT_ENTITIES, $MAP, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ALIASES, ENTITY, $ENTITY, typeof referenceComponent>, targetReflection: DomainEntityReflection<TARGET_ENTITY> | RawAliasReflection<TARGET_ENTITY>, field: SingleReferenceField<ENTITY, TARGET_ENTITY, any>) => import("../components/domain-component-optic.js").DomainComponentSimpleOptic<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ENTITY, import("../index.js").SystemComponentType<"reference", ReferenceComponentState, "referencedEntityIds">>;
-export declare const attachMultipleReferenceComponent: <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>, ENTITY extends ENTITIES, $ENTITY extends $DomainEntity<ENTITY>, TARGET_ENTITY extends ENTITIES>(attachComponent: DomainComponentOpticBuilder<ENTITIES, ALLOWED_ROOT_ENTITIES, $MAP, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ALIASES, ENTITY, $ENTITY, typeof referenceComponent>, targetReflection: DomainEntityReflection<TARGET_ENTITY> | RawAliasReflection<TARGET_ENTITY>, field: ArrayReferenceField<ENTITY, TARGET_ENTITY>) => import("../components/domain-component-optic.js").DomainComponentSimpleOptic<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ENTITY, import("../index.js").SystemComponentType<"reference", ReferenceComponentState, "referencedEntityIds">>;
+export declare const attachSingleReferenceComponent: <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>, ENTITY extends ENTITIES, $ENTITY extends $DomainEntity<ENTITY>, TARGET_ENTITY extends ENTITIES>(attachComponent: DomainComponentOpticBuilder<ENTITIES, ALLOWED_ROOT_ENTITIES, $MAP, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ALIASES, ENTITY, $ENTITY, typeof referenceComponent>, targetReflection: DomainEntityReflection<TARGET_ENTITY> | RawAliasReflection<TARGET_ENTITY>, field: SingleReferenceField<ENTITY, TARGET_ENTITY, any>) => import("../index.js").DomainComponentSimpleOptic<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ENTITY, import("../index.js").SystemComponentType<"reference", ReferenceComponentState, "referencedEntityIds">>;
+export declare const attachMultipleReferenceComponent: <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>, ENTITY extends ENTITIES, $ENTITY extends $DomainEntity<ENTITY>, TARGET_ENTITY extends ENTITIES>(attachComponent: DomainComponentOpticBuilder<ENTITIES, ALLOWED_ROOT_ENTITIES, $MAP, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ALIASES, ENTITY, $ENTITY, typeof referenceComponent>, targetReflection: DomainEntityReflection<TARGET_ENTITY> | RawAliasReflection<TARGET_ENTITY>, field: ArrayReferenceField<ENTITY, TARGET_ENTITY>) => import("../index.js").DomainComponentSimpleOptic<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ENTITY, import("../index.js").SystemComponentType<"reference", ReferenceComponentState, "referencedEntityIds">>;

package/dist/domain/core/relation/reference-component.js

@@ -0,0 +1 @@
+import{memoEval as e}from"../../utils/memo-eval.js";import{SystemComponentBuilder as t}from"../component/index.js";import{EntityIdSchema as r}from"../model/index.js";export const referenceComponent=t.component("reference").withState({type:"object",properties:{referencedEntityIds:{type:"array",items:r}},required:["referencedEntityIds"],additionalProperties:!1}).withWritableKeys(["referencedEntityIds"]).build();export const attachSingleReferenceComponent=(t,r,n)=>t.attach(e(e=>[e[n]],e=>({referencedEntityIds:null===e?[]:[e]})),e=>{let t=e.referencedEntityIds[0];return t&&r.assertId(t),{[n]:t??null}});export const attachMultipleReferenceComponent=(t,r,n)=>t.attach(e(e=>[e[n]],e=>({referencedEntityIds:e})),e=>(r.assertIds(e.referencedEntityIds),{[n]:e.referencedEntityIds}));

package/dist/domain/{relations → core/relation}/reference-field.d.ts

@@ -1,4 +1,4 @@
-import type { DomainEntity } from '../core/model.js';
+import type { DomainEntity } from '../model/index.js';
 export type SingleReferenceField<FROM extends DomainEntity<string>, TO extends DomainEntity<string>, OPTIONALITY extends null | never> = {
     [K in keyof FROM]: TO['id'] | OPTIONALITY extends FROM[K] ? FROM[K] extends TO['id'] | OPTIONALITY ? K & string : never : never;
 }[keyof FROM];

package/dist/domain/core/relation/reference-field.js

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