@salsita-ai/sdk 0.50.0-develop.dfac20c66b → 0.50.0-develop.e33c8d8711

package/dist/domain/components/system-virtual-entity.js

@@ -1 +0,0 @@
-import{createVirtualEntityId as t}from"../core/model.js";export const systemVirtualEntityId=t("system");

package/dist/domain/components/tool-state-component.d.ts

@@ -1,14 +0,0 @@
-import type { EntityId } from '../core/model.js';
-export type ToolStateComponentState = {
-    readonly activeState: string;
-};
-/**
- * Component used to hold tool state for system virtual entity. Use this only via NavigationSystem
- */
-export declare const toolStateComponent: import("../index.js").SystemComponentType<"toolState", ToolStateComponentState, "activeState">;
-/**
- * Component used to hold tool state for system virtual entity. Use this only via NavigationSystem
- */
-export type ToolStateComponent = typeof toolStateComponent;
-export declare const isToolStateComponentSnapshot: (entityId: EntityId) => (snapshot: import("../index.js").ComponentSnapshot<import("../index.js").SystemComponentTypeConstraint>) => snapshot is import("../index.js").ComponentSnapshot<import("../index.js").SystemComponentType<"toolState", ToolStateComponentState, "activeState">>;
-export declare const isSystemToolStateComponentSnapshot: (snapshot: import("../index.js").ComponentSnapshot<import("../index.js").SystemComponentTypeConstraint>) => snapshot is import("../index.js").ComponentSnapshot<import("../index.js").SystemComponentType<"toolState", ToolStateComponentState, "activeState">>;

package/dist/domain/components/tool-state-component.js

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

package/dist/domain/components/updates.d.ts

@@ -1,108 +0,0 @@
-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 { OneComponentFilter } from './component-reader-types.js';
-export interface ComponentModification<COMPONENT_TYPE extends SystemComponentTypeConstraint> {
-    kind: 'modifyComponent';
-    entityId: EntityId;
-    updateTag: string;
-    hint?: Localizable;
-    componentInstance: ComponentInstance<COMPONENT_TYPE>;
-    writableState: WritableStateOfComponent<COMPONENT_TYPE>;
-    metadata?: Record<string, unknown>;
-}
-export declare const isComponentModificationOfType: <COMPONENT_TYPE extends SystemComponentTypeConstraint>(componentType: COMPONENT_TYPE) => (update: StateUpdate<any, any>) => update is ComponentModification<COMPONENT_TYPE>;
-export interface EphemeralRecordModification<COMPONENT_TYPE extends SystemComponentTypeConstraint = SystemComponentTypeConstraint> {
-    kind: 'modifyEphemeralRecord';
-    entityId: EntityId;
-    updateTag: string;
-    hint?: Localizable;
-    componentInstance: ComponentInstance<COMPONENT_TYPE>;
-    writableState: WritableStateOfComponent<COMPONENT_TYPE>;
-}
-export interface EphemeralRecordCreation<COMPONENT_TYPE extends SystemComponentTypeConstraint = SystemComponentTypeConstraint> {
-    kind: 'createEphemeralRecord';
-    entityId: EntityId;
-    updateTag: string;
-    hint?: Localizable;
-    componentInstance: ComponentInstance<COMPONENT_TYPE>;
-    initialState: StateOfComponent<COMPONENT_TYPE>;
-}
-export interface EphemeralRecordDeletion<COMPONENT_TYPE extends SystemComponentTypeConstraint = SystemComponentTypeConstraint> {
-    kind: 'deleteEphemeralRecord';
-    entityId: EntityId;
-    componentInstance: ComponentInstance<COMPONENT_TYPE>;
-    updateTag: string;
-    hint?: Localizable;
-}
-export type DomainEntityStateDelta<ENTITY extends DomainEntity<string>> = Partial<Omit<ENTITY, 'id' | 'type'>>;
-export interface DomainEntityModification<ENTITY extends DomainEntity<string> = DomainEntity<string>> {
-    kind: 'modifyDomainEntity';
-    entityId: ENTITY['id'];
-    updateTag: string;
-    hint?: Localizable;
-    stateDelta: DomainEntityStateDelta<ENTITY>;
-    origin?: ComponentModification<SystemComponentTypeConstraint>;
-}
-export interface DomainEntityCreation<ENTITY extends DomainEntity<string>, PARENT extends DomainEntity<string>> {
-    kind: 'createDomainEntity';
-    entityId: ENTITY['id'];
-    entity: ENTITY;
-    updateTag: string;
-    /**
-     * Collection this entity is part of. This should be the instanceName of referenceComponents where this entity should be added.
-     */
-    collection?: string;
-    parentId: PARENT['id'];
-    hint?: Localizable;
-}
-export interface DomainEntityReplacement<ENTITY extends DomainEntity<string>> {
-    kind: 'replaceDomainEntity';
-    entityId: EntityId<ENTITY>;
-    replacementEntity: ENTITY;
-    updateTag: string;
-    keepChildren: boolean;
-    hint?: Localizable;
-}
-export interface EntityDeletion<ENTITY extends DomainEntity<string>> {
-    kind: 'deleteEntity';
-    entityId: EntityId<ENTITY>;
-    updateTag: string;
-    hint?: Localizable;
-}
-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>;
-type ComponentUpdate<COMPONENT_TYPE extends SystemComponentTypeConstraint> = ComponentModification<COMPONENT_TYPE> | EphemeralRecordModification<COMPONENT_TYPE> | EphemeralRecordCreation<COMPONENT_TYPE> | EphemeralRecordDeletion<COMPONENT_TYPE>;
-type ComponentUpdateDetails<COMPONENT_TYPE extends SystemComponentTypeConstraint, UPDATE extends ComponentUpdate<COMPONENT_TYPE>> = {
-    readonly componentInstance: OneComponentFilter<COMPONENT_TYPE>;
-} & (COMPONENT_TYPE extends SystemComponentType<any, Record<never, never>, never> ? Omit<UPDATE, 'kind' | 'entityId' | 'componentInstance' | 'writableState' | 'initialState'> : Omit<UPDATE, 'kind' | 'entityId' | 'componentInstance'>);
-export declare const createUpdateFactory: <ENTITIES extends DomainEntity<string>>() => {
-    ComponentModification: <COMPONENT_TYPE extends SystemComponentTypeConstraint>(details: ComponentUpdateDetails<COMPONENT_TYPE, ComponentModification<COMPONENT_TYPE>>) => ComponentModification<COMPONENT_TYPE>;
-    DomainEntityCreation: <ENTITY extends ENTITIES, PARENT extends ENTITIES>(details: Omit<DomainEntityCreation<ENTITY, PARENT>, 'kind' | 'entityId'>) => DomainEntityCreation<ENTITY, PARENT>;
-    DomainEntityReplacement: <ENTITY extends ENTITIES>(details: Omit<DomainEntityReplacement<ENTITY>, 'kind'>) => DomainEntityReplacement<ENTITY>;
-    EphemeralRecordCreation: <COMPONENT_TYPE extends SystemComponentTypeConstraint>(details: ComponentUpdateDetails<COMPONENT_TYPE, EphemeralRecordCreation<COMPONENT_TYPE>>) => EphemeralRecordCreation<COMPONENT_TYPE>;
-    DomainEntityModification: <TYPE extends ENTITIES['type']>(details: Omit<DomainEntityModification<EntityByType<ENTITIES, TYPE>>, 'kind'>) => DomainEntityModification<EntityByType<ENTITIES, TYPE>>;
-    EphemeralRecordModification: <COMPONENT_TYPE extends SystemComponentTypeConstraint>(details: ComponentUpdateDetails<COMPONENT_TYPE, EphemeralRecordModification<COMPONENT_TYPE>>) => EphemeralRecordModification<COMPONENT_TYPE>;
-    EphemeralRecordDeletion: <COMPONENT_TYPE extends SystemComponentTypeConstraint>(details: ComponentUpdateDetails<COMPONENT_TYPE, EphemeralRecordDeletion<COMPONENT_TYPE>>) => EphemeralRecordDeletion<COMPONENT_TYPE>;
-    EntityDeletion: <ENTITY extends ENTITIES>(details: Omit<EntityDeletion<ENTITY>, 'kind'>) => EntityDeletion<ENTITY>;
-};
-export type UpdateFactory<ENTITIES extends DomainEntity<string>> = ReturnType<typeof createUpdateFactory<ENTITIES>>;
-/**
- * Factory for creating system updates. It is not typed to a specific domain.
- * This should never be used in a project code! It is just internal tool for sdk.
- */
-export declare const systemUpdateFactory: {
-    ComponentModification: <COMPONENT_TYPE extends SystemComponentTypeConstraint>(details: ComponentUpdateDetails<COMPONENT_TYPE, ComponentModification<COMPONENT_TYPE>>) => ComponentModification<COMPONENT_TYPE>;
-    DomainEntityCreation: <ENTITY extends DomainEntity<string>, PARENT extends DomainEntity<string>>(details: Omit<DomainEntityCreation<ENTITY, PARENT>, "entityId" | "kind">) => DomainEntityCreation<ENTITY, PARENT>;
-    DomainEntityReplacement: <ENTITY extends DomainEntity<string>>(details: Omit<DomainEntityReplacement<ENTITY>, "kind">) => DomainEntityReplacement<ENTITY>;
-    EphemeralRecordCreation: <COMPONENT_TYPE extends SystemComponentTypeConstraint>(details: ComponentUpdateDetails<COMPONENT_TYPE, EphemeralRecordCreation<COMPONENT_TYPE>>) => EphemeralRecordCreation<COMPONENT_TYPE>;
-    DomainEntityModification: <TYPE extends string>(details: Omit<DomainEntityModification<Extract<DomainEntity<string>, {
-        type: TYPE;
-    }>>, "kind">) => DomainEntityModification<Extract<DomainEntity<string>, {
-        type: TYPE;
-    }>>;
-    EphemeralRecordModification: <COMPONENT_TYPE extends SystemComponentTypeConstraint>(details: ComponentUpdateDetails<COMPONENT_TYPE, EphemeralRecordModification<COMPONENT_TYPE>>) => EphemeralRecordModification<COMPONENT_TYPE>;
-    EphemeralRecordDeletion: <COMPONENT_TYPE extends SystemComponentTypeConstraint>(details: ComponentUpdateDetails<COMPONENT_TYPE, EphemeralRecordDeletion<COMPONENT_TYPE>>) => EphemeralRecordDeletion<COMPONENT_TYPE>;
-    EntityDeletion: <ENTITY extends DomainEntity<string>>(details: Omit<EntityDeletion<ENTITY>, "kind">) => EntityDeletion<ENTITY>;
-};
-export {};

package/dist/domain/components/view-state-component.d.ts

@@ -1,14 +0,0 @@
-import type { EntityId } from '../core/model.js';
-export type ViewStateComponentState = {
-    readonly activeState: string;
-};
-/**
- * Component used to hold view state for system virtual entity. Use this only via NavigationSystem
- */
-export declare const viewStateComponent: import("../index.js").SystemComponentType<"viewState", ViewStateComponentState, "activeState">;
-/**
- * Component used to hold view state for system virtual entity. Use this only via NavigationSystem
- */
-export type ViewStateComponent = typeof viewStateComponent;
-export declare const isViewComponentSnapshot: (entityId: EntityId) => (snapshot: import("../index.js").ComponentSnapshot<import("../index.js").SystemComponentTypeConstraint>) => snapshot is import("../index.js").ComponentSnapshot<import("../index.js").SystemComponentType<"viewState", ViewStateComponentState, "activeState">>;
-export declare const isSystemViewComponentSnapshot: (snapshot: import("../index.js").ComponentSnapshot<import("../index.js").SystemComponentTypeConstraint>) => snapshot is import("../index.js").ComponentSnapshot<import("../index.js").SystemComponentType<"viewState", ViewStateComponentState, "activeState">>;

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

@@ -1 +0,0 @@
-import{isSnapshotInstance as t}from"../core/component.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/viewport-state-component.d.ts

@@ -1,29 +0,0 @@
-import type { EntityId } from '../core/model.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`,
- * `isTablet`, `isDesktop`, `isLandscape`, `isPortrait`), so several can be active at once —
- * a 600px wide container is `mobile` and `tablet` at the same time.
- */
-export type Viewport = 'phone' | 'mobile' | 'tablet' | 'desktop' | 'landscape' | 'portrait';
-export declare const VIEWPORTS: readonly ["phone", "mobile", "tablet", "desktop", "landscape", "portrait"];
-export type ViewportStateComponentState = {
-    /**
-     * Every viewport class the container currently satisfies, or `null` while nothing has measured
-     * the container yet (image rendering, tests, non-browser evaluation). Component filters skip
-     * their `viewports` criterion while the value is `null`.
-     */
-    readonly active: readonly Viewport[] | null;
-};
-/**
- * Component used to hold the active responsive viewport classes for the system virtual entity.
- * Seeded by the NavigationSystem and written by the configurator UI whenever the responsive
- * flags change. Use this only via NavigationSystem.
- */
-export declare const viewportStateComponent: import("../index.js").SystemComponentType<"viewportState", ViewportStateComponentState, "active">;
-/**
- * Component used to hold the active responsive viewport classes for the system virtual entity. Use this only via NavigationSystem
- */
-export type ViewportStateComponent = typeof viewportStateComponent;
-export declare const isViewportStateComponentSnapshot: (entityId: EntityId) => (snapshot: import("../index.js").ComponentSnapshot<import("../index.js").SystemComponentTypeConstraint>) => snapshot is import("../index.js").ComponentSnapshot<import("../index.js").SystemComponentType<"viewportState", ViewportStateComponentState, "active">>;
-export declare const isSystemViewportStateComponentSnapshot: (snapshot: import("../index.js").ComponentSnapshot<import("../index.js").SystemComponentTypeConstraint>) => snapshot is import("../index.js").ComponentSnapshot<import("../index.js").SystemComponentType<"viewportState", ViewportStateComponentState, "active">>;

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

@@ -1 +0,0 @@
-import{isSnapshotInstance as t}from"../core/component.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/action.d.ts

@@ -1,67 +0,0 @@
-import type { ExtendedJsonSchema } from '@salsita-ai/common/utils';
-import type { StateUpdate, UpdateFactory } from '../components/updates.js';
-import type { DomainContextSystems } from '../domain-context/domain-context-systems.js';
-import type { IdSequence } from '../domain-context/store-system/next-domain-entity-id.js';
-import type { ExpressionContext } from './expression.js';
-import type { $DomainEntity, DomainEntity } from './model.js';
-import type { DomainState } from './state.js';
-/**
- * The parameter and result types of the actions an application declares under `actions`, keyed by
- * action name. Codegen derives it from the spec; `ActionSystem.prepareAction` and the
- * `implementActions` factory are typed against it.
- */
-export type ActionTypes = Record<string, {
-    readonly params: unknown;
-    readonly result: unknown;
-}>;
-/**
- * One action as the spec declares it, carried into the domain factory by the generated code:
- * `params` is the AJV-ready object schema of its parameters, which `prepareAction` validates the
- * arguments against before the implementation runs, and `description` says what the action does.
- */
-export interface ActionDefinition {
-    readonly name: string;
-    readonly description?: string;
-    readonly params: ExtendedJsonSchema;
-}
-/** The declared actions of an application by name; empty when the spec declares none. */
-export type ActionDefinitions = Readonly<Record<string, ActionDefinition>>;
-/** The working state an action ran against and the state its applied updates produced. */
-export interface ActionStateChange<ENTITIES extends DomainEntity<string>> {
-    readonly previousState: DomainState<ENTITIES>;
-    readonly state: DomainState<ENTITIES>;
-}
-/**
- * What one action prepares: the updates it wants applied, computed from the state it ran against,
- * and how to read its result from the change they made, including whatever the transformers added.
- * Nothing is staged or committed; the caller decides what to do with the updates.
- */
-export interface PreparedAction<ENTITIES extends DomainEntity<string>, RESULT> {
-    readonly updates: ReadonlyArray<StateUpdate<ENTITIES, ENTITIES>>;
-    readonly readResult: (change: ActionStateChange<ENTITIES>) => RESULT;
-}
-/**
- * What an action implementation reads besides its parameters and the state: the expression context
- * (domain, data, projections), the domain systems, an id sequence for entities it creates, and the
- * update factory typed for the application's entities.
- */
-export interface ActionContext<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>, NAVIGATION_STATES extends string, VIEW_STATES extends string, TOOL_STATES extends string, EXPORT_STATES extends string> {
-    readonly expressionContext: ExpressionContext<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA>;
-    readonly systems: DomainContextSystems<ENTITIES, ALLOWED_ROOT_ENTITIES, $MAP, NAVIGATION_STATES, VIEW_STATES, TOOL_STATES, EXPORT_STATES>;
-    readonly getIdSequence: () => IdSequence<ENTITIES>;
-    readonly updates: UpdateFactory<ENTITIES>;
-}
-export type AnyActionContext = ActionContext<any, any, any, any, any, any, any, any, any, any>;
-/**
- * The implementation of one declared action. It must not change anything itself; a thrown error
- * fails the call, and its message reaches whoever asked for the action, so it says what went wrong
- * and how to fix the request.
- */
-export type ActionImplementation<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>, NAVIGATION_STATES extends string, VIEW_STATES extends string, TOOL_STATES extends string, EXPORT_STATES extends string, PARAMS, RESULT> = (params: PARAMS, state: DomainState<ENTITIES>, context: ActionContext<ENTITIES, ALLOWED_ROOT_ENTITIES, $MAP, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, NAVIGATION_STATES, VIEW_STATES, TOOL_STATES, EXPORT_STATES>) => PreparedAction<ENTITIES, RESULT>;
-export type AnyActionImplementation = ActionImplementation<any, any, any, any, any, any, any, any, any, any, any, unknown>;
-/** The implementations of every declared action by name, as the generated barrel merges them from `src/actions/`. */
-export type ActionImplementations<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>, NAVIGATION_STATES extends string, VIEW_STATES extends string, TOOL_STATES extends string, EXPORT_STATES extends string, ACTION_TYPES extends ActionTypes> = {
-    readonly [NAME in keyof ACTION_TYPES]: ActionImplementation<ENTITIES, ALLOWED_ROOT_ENTITIES, $MAP, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, NAVIGATION_STATES, VIEW_STATES, TOOL_STATES, EXPORT_STATES, ACTION_TYPES[NAME]['params'], ACTION_TYPES[NAME]['result']>;
-};
-/** The action implementations of an application with their types erased, as the runtime spec slice holds them. */
-export type AnyActionImplementations = Readonly<Record<string, AnyActionImplementation>>;

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

@@ -1,46 +0,0 @@
-import { type ExtendedJsonSchema } from '@salsita-ai/common/utils';
-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.
- */
-export interface SystemComponentType<NAME extends string, COMPONENT_STATE extends Record<string, unknown>, WRITABLE_KEYS extends keyof COMPONENT_STATE> {
-    readonly name: NAME;
-    readonly writableKeys: WRITABLE_KEYS[];
-    readonly schema: ExtendedJsonSchema;
-    readonly validateState: PhxValidateFunction<COMPONENT_STATE>;
-    readonly validateWritableState: PhxValidateFunction<Pick<COMPONENT_STATE, WRITABLE_KEYS>>;
-}
-/**
- * Concrete version of SystemComponentType with the widest possible constraints. Use it when you don't care about generic constraints
- * of component types, eg. in extend expressions.
- */
-export type SystemComponentTypeConstraint = SystemComponentType<string, Record<string, unknown>, string>;
-/**
- * Instantiation of a component for a specific entity and instance name. It is used as concrete identification of a component in the system.
- */
-export interface ComponentInstance<COMPONENT_TYPE extends SystemComponentTypeConstraint> {
-    readonly entityId: EntityId;
-    readonly instanceName: string;
-    readonly componentType: COMPONENT_TYPE;
-}
-export declare const isInstanceOfComponentType: <COMPONENT_TYPE extends SystemComponentTypeConstraint>(componentType: COMPONENT_TYPE) => (instance: ComponentInstance<SystemComponentTypeConstraint>) => instance is ComponentInstance<COMPONENT_TYPE>;
-/**
- * Checks if two component instances are equal - are of same ComponentType, belong to the same entity and have the same instance name.
- */
-export declare const isEqualComponentInstance: (a: ComponentInstance<SystemComponentTypeConstraint>, b: ComponentInstance<SystemComponentTypeConstraint>) => boolean;
-export type StateOfComponent<COMPONENT_TYPE extends SystemComponentTypeConstraint> = COMPONENT_TYPE extends SystemComponentType<any, infer COMPONENT_STATE, any> ? COMPONENT_STATE : never;
-export type WritableStateOfComponent<COMPONENT_TYPE extends SystemComponentTypeConstraint> = COMPONENT_TYPE extends SystemComponentType<any, infer COMPONENT_STATE, infer WRITABLE_KEYS> ? Pick<COMPONENT_STATE, WRITABLE_KEYS> : never;
-/**
- * Instantiated component for a given entity/instanceName with a state. Snapshots are returned from the component reader.
- */
-export interface ComponentSnapshot<COMPONENT_TYPE extends SystemComponentTypeConstraint> {
-    readonly componentInstance: ComponentInstance<COMPONENT_TYPE>;
-    readonly state: StateOfComponent<COMPONENT_TYPE>;
-}
-export declare const isEqualComponentSnapshot: (a: ComponentSnapshot<SystemComponentTypeConstraint>, b: ComponentSnapshot<SystemComponentTypeConstraint>) => boolean;
-export declare const areEqualComponentSnapshots: (a: ReadonlyArray<ComponentSnapshot<SystemComponentTypeConstraint>>, b: ReadonlyArray<ComponentSnapshot<SystemComponentTypeConstraint>>) => boolean;
-export declare const isSnapshotOfComponentType: <COMPONENT_TYPE extends SystemComponentTypeConstraint>(componentType: COMPONENT_TYPE) => (snapshot: ComponentSnapshot<SystemComponentTypeConstraint>) => snapshot is ComponentSnapshot<COMPONENT_TYPE>;
-export declare const isSnapshotInstance: <COMPONENT_TYPE extends SystemComponentTypeConstraint>(entityId: EntityId, instanceName: string, componentType: COMPONENT_TYPE) => (snapshot: ComponentSnapshot<SystemComponentTypeConstraint>) => snapshot is ComponentSnapshot<COMPONENT_TYPE>;
-export declare const getComponentInstanceKey: (componentInstance: ComponentInstance<SystemComponentTypeConstraint>) => string;
-export declare const getComponentSnapshotKey: (snapshot: ComponentSnapshot<SystemComponentTypeConstraint>) => string;

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

@@ -1,50 +0,0 @@
-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';
-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;
-    readonly publishedData: PUBLISHED_DATA;
-    readonly frontendData: FRONTEND_DATA;
-    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>;
-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.
- */
-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;
-    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> {
-    readonly origin: ExpressionOrigin;
-}
-export type AnyExpression = Expression<any, any, any, any, any, any, any>;
-export type AnyExpressions = Record<string, Record<string, AnyExpression>>;

package/dist/domain/core/json-schema.js

@@ -1 +0,0 @@
-import{createAjvSchemaValidator as e}from"./schema-validator-ajv.js";import{createCspSchemaValidator as a}from"./schema-validator-csp.js";let d="csp-compatible"===globalThis.PHX_SCHEMA_VALIDATOR?a:e;export const getExtendedSchemaValidator=()=>{let e=d();return e.addKeyword("tsType"),e.addKeyword("import"),e.addKeyword("declared"),e};export const extendedSchemaValidator=getExtendedSchemaValidator();

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

@@ -1,99 +0,0 @@
-import { type Logger } from '@salsita-ai/common/utils';
-import type { DomainEntity } from './model.js';
-import type { EntityReflections } from './reflection.js';
-/**
- * Thrown when domain state cannot be validated/migrated to the latest model
- * version: an entity is invalid against its schema, an entity type or model
- * version is unknown, or a migration is missing.
- */
-export declare class StateMigrationError extends Error {
-    constructor(message: string);
-}
-export declare const isStateMigrationError: (error: unknown) => error is StateMigrationError;
-/**
- * Migration between two consecutive versions of the model.
- */
-export type Migration<FROM extends DomainEntity<string>, TO extends DomainEntity<string>> = (state: readonly FROM[]) => readonly TO[];
-/**
- * Domain state (array of entities) with a version number attached.
- */
-export interface VersionedState<VERSION extends number, ENTITIES extends DomainEntity<string>> {
-    version: VERSION;
-    state: readonly ENTITIES[];
-}
-/**
- * Simple helper type to extract the entity types from their reflections.
- */
-type EntitiesOfReflections<REFLECTIONS extends EntityReflections<DomainEntity<string>>> = REFLECTIONS extends EntityReflections<infer ENTITIES> ? ENTITIES : never;
-/**
- * Union of all versioned states for all versions of the model.
- */
-export type AnyVersionedState<VERSIONS extends Record<number, EntityReflections<any>>> = {
-    [VERSION in keyof VERSIONS & number]: VersionedState<VERSION, EntitiesOfReflections<VERSIONS[VERSION]>>;
-}[keyof VERSIONS & number];
-export interface MigrateFunctionOptions {
-    logger?: Logger;
-    /**
-     * If true, extra properties in entities will be removed during migration.
-     *
-     * This should be set to `true` in production environment ONLY. In all other environments, extra properties should
-     * cause the migration to fail.
-     */
-    trimExtraProperties: boolean;
-}
-/**
- * Function that migrates the state between any arbitrary versions of the model always to the latest version.
- */
-export type MigrateFunction<LATEST_ENTITIES extends DomainEntity<string>> = (versionedState: {
-    version: number;
-    state: ReadonlyArray<DomainEntity<string>>;
-}, options: MigrateFunctionOptions) => readonly LATEST_ENTITIES[];
-/**
- * Builder for the state migration function.
- * @example
-
- export const migrateState = MigrateFunctionBuilder
-
-   // the reflections are used for validation and sanitization
-   .fromVersions({
-     1: v1Reflections,
-     2: v2Reflections,
-     3: v3Reflections,
-   })
-
-   // the latest version of the model
-   .to(2)
-
-   // the migrations between the versions
-   .using({
-     2: migrationToV2,
-     3: migrationToV3,
-   })
-
-   .build()
-
- */
-export declare const MigrateFunctionBuilder: {
-    /**
-     * Provide the entity reflections for all versions of the model.
-     */
-    fromVersions: <VERSIONS extends Record<number, EntityReflections<any>>>(modelVersions: VERSIONS) => {
-        /**
-         * Specify the latest version of the model. I.e. the version to which the state will be migrated.
-         */
-        to: <LATEST extends keyof VERSIONS & number>(latestVersion: LATEST) => {
-            /**
-             * Provide the migrations between each consecutive version of the model.
-             *
-             * Migration with index `i` should migrate the state from version `i - 1` to version `i`.
-             */
-            using: (migrations: Record<Exclude<keyof VERSIONS, 1>, Migration<any, any>>) => {
-                /**
-                 * Finally, build the migration function.
-                 */
-                build: () => MigrateFunction<EntitiesOfReflections<VERSIONS[LATEST]>>;
-            };
-        };
-    };
-};
-export {};

package/dist/domain/core/migrations.js

@@ -1 +0,0 @@
-import e from"lodash-es/pick.js";export class StateMigrationError extends Error{constructor(e){super(e),this.name="StateMigrationError"}}export const isStateMigrationError=e=>e instanceof StateMigrationError;let t=(t,r,i,o)=>t.map(t=>{let n=r[t.type];if(!n)throw new StateMigrationError(`Unknown entity type "${t.type}". The state contains an entity whose type is not registered in the domain model for this version. Fix: register the entity type in the domain spec, or remove/migrate the stale entity from the preset or configuration data.`);if(n._meta.validator(t))return t;if(i){let r=e(t,Object.keys(n._meta.schema.properties));if(n._meta.validator(t))return o?.error(`Entity ${t.type}#${t.id} had extra fields that had to be trimmed: ${Object.keys(r)}`),r}throw new StateMigrationError(`Entity "${t.type}#${t.id}" does not match its schema in the current domain model. Validation errors: ${JSON.stringify(n._meta.validator.errors)}. Fix: update the entity data to match the schema, add a migration that transforms older data into the current shape, or re-register the schema if it changed.`)});export const MigrateFunctionBuilder={fromVersions:e=>({to:r=>({using:i=>({build:()=>(o,{logger:n,trimExtraProperties:a})=>{let s=e[o.version];if(!s)throw new StateMigrationError(`Unknown model version ${o.version}. The state declares a version that has no registered reflections. Fix: register the version in MigrateFunctionBuilder.fromVersions({ ... }), or correct the version stored on the state.`);let d=t(o.state,s,a,n);o.version===r?n?.debug(`State is already in the latest version ${r}`):n?.debug(`Migrating state from version ${o.version} to ${r}`);for(let s=o.version;s<r;s++){n?.debug(`Applying intermediate migration to version ${s+1}`);let h=e[s+1];if(!h)throw new StateMigrationError(`Unknown model version ${s+1} while migrating from ${o.version} to ${r}. An intermediate version has no registered reflections. Fix: register version ${s+1} in MigrateFunctionBuilder.fromVersions({ ... }).`);let g=i[s+1];if(!g)throw new StateMigrationError(`Missing migration from version ${s} to ${s+1}. No migration is registered for this step while migrating to ${r}. Fix: add the migration in MigrateFunctionBuilder.using({ ${s+1}: ... }).`);d=t(g(d),h,a,n)}if(!e[o.version])throw new StateMigrationError(`Unknown model version ${o.version}. The state declares a version that has no registered reflections. Fix: register the version in MigrateFunctionBuilder.fromVersions({ ... }), or correct the version stored on the state.`);return d}})})})};

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

@@ -1,127 +0,0 @@
-declare const VirtualEntityIdSymbol: unique symbol;
-export interface VirtualEntityId {
-    [VirtualEntityIdSymbol]: true;
-    name: string;
-    toString: () => string;
-}
-export declare const VirtualEntityIdSchema: {
-    readonly type: 'object';
-    readonly properties: {
-        readonly [VirtualEntityIdSymbol]: {
-            readonly type: 'boolean';
-            readonly const: true;
-        };
-        readonly name: {
-            readonly type: 'string';
-        };
-    };
-    readonly required: ["name"];
-    readonly additionalProperties: false;
-    readonly import: [{
-        readonly module: '@salsita-ai/sdk/domain';
-        readonly member: 'VirtualEntityId';
-    }];
-    readonly tsType: 'VirtualEntityId';
-};
-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}` & {
-    __brand: TYPE;
-};
-/**
- * This function is meant for internal use and for test fixtures only.
- * **DO NOT USE IT IN PRODUCTION CODE.**
- */
-export declare const _unsafeBuildDomainEntityId: <TYPE extends string>(type: TYPE, sequenceNumber: number) => DomainEntityId<TYPE>;
-export declare const parseDomainEntityId: <TYPE extends string>(id: DomainEntityId<TYPE>) => {
-    type: TYPE;
-    sequenceNumber: number;
-};
-export declare const domainEntityTypeFromId: <TYPE extends string>(id: DomainEntityId<TYPE>) => TYPE;
-export declare const isDomainEntityId: <ENTITIES extends DomainEntity<string> = DomainEntity<string>>(value: EntityId<ENTITIES>) => value is ENTITIES['id'];
-export declare const isEqualEntityTypeAndId: (a: DomainEntity<string>, b: DomainEntity<string>) => boolean;
-export declare const DomainEntityIdSchema: {
-    readonly type: 'string';
-    readonly pattern: '^[A-Z]\\w*-\\d+$';
-    readonly import: [{
-        readonly module: '@salsita-ai/sdk/domain';
-        readonly member: 'DomainEntityId';
-    }];
-    readonly tsType: 'DomainEntityId';
-};
-export type EntityId<ENTITY extends DomainEntity<string> = DomainEntity<string>> = ENTITY['id'] | VirtualEntityId;
-export declare const EntityIdSchema: {
-    readonly anyOf: [{
-        readonly type: 'string';
-        readonly pattern: '^[A-Z]\\w*-\\d+$';
-        readonly import: [{
-            readonly module: '@salsita-ai/sdk/domain';
-            readonly member: 'DomainEntityId';
-        }];
-        readonly tsType: 'DomainEntityId';
-    }, {
-        readonly type: 'object';
-        readonly properties: {
-            readonly [VirtualEntityIdSymbol]: {
-                readonly type: 'boolean';
-                readonly const: true;
-            };
-            readonly name: {
-                readonly type: 'string';
-            };
-        };
-        readonly required: ["name"];
-        readonly additionalProperties: false;
-        readonly import: [{
-            readonly module: '@salsita-ai/sdk/domain';
-            readonly member: 'VirtualEntityId';
-        }];
-        readonly tsType: 'VirtualEntityId';
-    }];
-};
-export interface DomainEntity<TYPE extends string> {
-    type: TYPE;
-    id: DomainEntityId<TYPE>;
-}
-export declare const DomainEntitySchema: {
-    readonly type: 'object';
-    readonly properties: {
-        readonly id: {
-            readonly $ref: '#/definitions/DomainEntityId';
-        };
-        readonly type: {
-            readonly type: 'string';
-        };
-    };
-    readonly import: [{
-        readonly module: '@salsita-ai/sdk/domain';
-        readonly member: 'DomainEntity';
-    }];
-    readonly tsType: 'DomainEntity';
-};
-export type $DomainEntity<ENTITY extends DomainEntity<string>> = ENTITY & {
-    _raw: ENTITY;
-};
-export declare const $DomainEntitySchema: {
-    readonly type: 'object';
-    readonly properties: {
-        readonly _raw: {
-            readonly $ref: '#/definitions/DomainEntity';
-        };
-        readonly id: {
-            readonly $ref: '#/definitions/DomainEntityId';
-        };
-        readonly type: {
-            readonly type: 'string';
-        };
-    };
-    readonly import: [{
-        readonly module: '@salsita-ai/sdk/domain';
-        readonly member: '$DomainEntity';
-    }];
-    readonly tsType: '$DomainEntity';
-};
-export type EntityByType<ENTITIES extends DomainEntity<string>, TYPE extends ENTITIES['type']> = Extract<ENTITIES, {
-    type: TYPE;
-}>;
-export {};