@salsita-ai/sdk 0.50.0-develop.1ddc7020fd → 0.50.0-develop.231285e85a

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

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

package/dist/domain/invariants/invariants.js

@@ -1 +0,0 @@
-import{expandAlias as t}from"../core/index.js";import{SHARED_FOLDER_HINT as e,createContractError as a,isRecord as i}from"../project-modules/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/), ${e}.`},n=t=>i(t)&&"function"==typeof t.evaluate,s=t=>i(t)&&Object.values(t).every(t=>Array.isArray(t)&&t.every(n));export const resolveInvariantModules=t=>{let e={};for(let i of t){if(!s(i.exports))throw a(i.origin,r,i.exports);for(let[t,a]of Object.entries(i.exports))e[t]=[...e[t]??[],...a]}return e};export class InvariantBuilder{aliasMap;invariants;constructor(t,e={}){this.aliasMap=t,this.invariants=e}withInvariantModules(t){return this.withInvariants(resolveInvariantModules(t))}withInvariants(e){let a={...this.invariants};return Object.entries(e).forEach(([e,i])=>{t(this.aliasMap,e).forEach(t=>{a[t]=[...a[t]??[],...i]})}),new InvariantBuilder(this.aliasMap,a)}_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/invariants/violation-component.js

@@ -1 +0,0 @@
-import{SystemComponentBuilder as o}from"../core/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/violation.d.ts

@@ -1,85 +0,0 @@
-import type { I18n } from '@lingui/core';
-import type { Localizable } from '@salsita-ai/common/utils';
-import type { $DomainEntity, DomainEntity, EntityId } from '../core/index.js';
-import type { StateEmission } from '../domain-context/store-system/store-system.js';
-/**
- * An **ORDERED** list of violation severities.
- * Do not change the order of the items in this list.
- */
-declare const VIOLATION_SEVERITIES: readonly [
-/**
- * A fatal error that will never be propagated to the scene, undo stack or saved.
- *
- *  If a feature uses "dry-run" to verify whether an action should be allowed,
- *  this severity will prohibit the change.
- */
-'fatal', 
-/**
- * Similar semantics to `fatal` - i.e. the violation will never be propagated to the scene, undo stack or saved
- * - but unlike `fatal`, "dry-run" will allow the change and expect a custom logic to suggest or apply a fix.
- */
-'fixable', 
-/**
- * A warning that will be propagated to the scene, undo stack and saved.
- * However, it will prevent the configuration from being "finalized" (e.g. added to e-commerce cart).
- */
-'warning', 
-/**
- * An informative notice that will be propagated to the scene, undo stack and saved.
- * This severity does not impose any restrictions on the configuration.
- */
-'notice'];
-export type ViolationSeverity = (typeof VIOLATION_SEVERITIES)[number];
-export declare const compareSeverity: (a: ViolationSeverity, b: ViolationSeverity) => number;
-export interface Violation<TYPE extends string> {
-    readonly type: TYPE;
-    readonly severity: ViolationSeverity;
-    readonly message?: Localizable;
-    /**
-     * Only violations with the highest priority will be shown during on input controls.
-     * If there are multiple violations with the same priority,
-     * all of them will be shown in the tooltip, concatenated with a dot.
-     *
-     * Default priority is 0.
-     */
-    readonly controlViolationPriority?: number;
-    /**
-     * An optional callback to format the violation message for control tooltips.
-     * Unlike the general `message` field, this callback receives the state emission
-     * and can format the message based on what updates occurred.
-     *
-     * @returns A message formatted specifically for this state emission,
-     * `null` to skip the message when generating tooltip text,
-     * or `undefined` to fallback to the general `message` field.
-     */
-    readonly formatControlViolationMessage?: (stateEmission: StateEmission<DomainEntity<string>, Record<string, $DomainEntity<DomainEntity<string>>>>, context: {
-        i18n: I18n;
-    }) => Localizable | undefined | null;
-}
-export declare const ViolationSchema: {
-    readonly type: 'object';
-    readonly properties: {
-        readonly type: {
-            readonly type: 'string';
-        };
-        readonly severity: {
-            readonly enum: ("fatal" | "fixable" | "notice" | "warning")[];
-        };
-        readonly message: {
-            readonly type: 'string';
-        };
-        readonly controlViolationPriority: {
-            readonly type: 'number';
-        };
-    };
-    readonly required: ["type", "severity"];
-    readonly additionalProperties: false;
-};
-export type ViolationTypesOf$Entity<$ENTITY extends $DomainEntity<DomainEntity<string>>> = $ENTITY extends {
-    $violations: ReadonlyArray<Violation<infer VIOLATION_TYPE>>;
-} ? VIOLATION_TYPE : never;
-export interface EntityViolation<ENTITIES extends DomainEntity<string>, VIOLATION_TYPE extends string> {
-    readonly entityId: EntityId<ENTITIES>;
-    readonly violation: Violation<VIOLATION_TYPE>;
-}
-export {};

package/dist/domain/invariants/violation.js

@@ -1 +0,0 @@
-let e=["fatal","fixable","warning","notice"];export const compareSeverity=(t,i)=>e.indexOf(t)-e.indexOf(i);export const ViolationSchema={type:"object",properties:{type:{type:"string"},severity:{enum:e.slice()},message:{type:"string"},controlViolationPriority:{type:"number"}},required:["type","severity"],additionalProperties:!1};

package/dist/domain/project-modules/index.d.ts

@@ -1 +0,0 @@
-export { type ExpressionModule, type ProjectModule, type ProjectModuleContract, SHARED_FOLDER_HINT, createContractError, isRecord, resolveActionModules, resolveExpressionModules, resolveListModule, } from './project-modules.js';

package/dist/domain/project-modules/index.js

@@ -1 +0,0 @@
-export{SHARED_FOLDER_HINT,createContractError,isRecord,resolveActionModules,resolveExpressionModules,resolveListModule}from"./project-modules.js";

package/dist/domain/project-modules/project-modules.d.ts

@@ -1,41 +0,0 @@
-import type { AnonymousExpression, AnyActionImplementations } from '../core/index.js';
-/**
- * The default export of one file in a project convention folder (`src/elements/`, `src/handlers/`,
- * `src/expressions/`, …), paired with the project-relative path it was imported from.
- *
- * Generated barrels and the editor's hot reload hand project code to the SDK in this shape, without
- * inspecting it. Each folder's resolver then checks the export against the folder's contract, so an
- * invalid file fails with an error naming it instead of an unrelated crash later.
- */
-export interface ProjectModule {
-    readonly origin: string;
-    readonly exports: unknown;
-}
-/** The expressions of one validated expression file, keyed by entity type or alias, then by expression name. */
-export interface ExpressionModule {
-    readonly origin: string;
-    readonly expressions: Readonly<Record<string, Readonly<Record<string, AnyAnonymousExpression>>>>;
-}
-type AnyAnonymousExpression = AnonymousExpression<any, any, any, any, any, any, unknown>;
-/** What a convention folder requires of its files, in the words used by the contract error. */
-export interface ProjectModuleContract {
-    readonly expected: string;
-    readonly fix: string;
-}
-export declare const SHARED_FOLDER_HINT = "or move the file to an underscore-prefixed folder such as src/_shared/ when it is shared code";
-export declare const isRecord: (value: unknown) => value is Record<string, unknown>;
-export declare const createContractError: (origin: string, contract: ProjectModuleContract, received: unknown) => Error;
-/**
- * Checks a file of a folder whose contract is one item or an array of them, and returns its items.
- * The first item that fails the check is the value the error reports.
- */
-export declare const resolveListModule: <Item>(module: ProjectModule, contract: ProjectModuleContract, isItem: (value: unknown) => value is Item) => readonly Item[];
-/**
- * Validates the `src/expressions/` files and rejects an expression that two files define for the
- * same entity type. Merging stays with the caller, because the domain builder and the editor expand
- * aliases at different points; within one file the builder's own duplicate check applies.
- */
-export declare const resolveExpressionModules: (modules: readonly ProjectModule[], aliasMap: Readonly<Record<string, readonly string[]>>) => readonly ExpressionModule[];
-/** Validates the `src/actions/` files and merges their implementations by action name; a later file wins. */
-export declare const resolveActionModules: (modules: readonly ProjectModule[]) => AnyActionImplementations;
-export {};

package/dist/domain/project-modules/project-modules.js

@@ -1 +0,0 @@
-export const SHARED_FOLDER_HINT="or move the file to an underscore-prefixed folder such as src/_shared/ when it is shared code";let e={expected:"an object of expressions keyed by entity type or alias, then by expression name",fix:`Create it with phx.domain.implementCustomExpressions({ ... }) (phx.domain.admin.implementCustomExpressions({ ... }) under src/admin/), ${SHARED_FOLDER_HINT}.`},t={expected:"an object of action implementations keyed by action name",fix:`Create it with phx.domain.implementActions({ ... }), ${SHARED_FOLDER_HINT}.`};export const isRecord=e=>"object"==typeof e&&null!==e&&!Array.isArray(e);export const createContractError=(e,t,r)=>Error(`Invalid default export in ${e}: expected ${t.expected}, but got ${(e=>{if(void 0===e)return"nothing (the file has no default export)";if(null===e)return"null";if("function"==typeof e)return e.name?`the function "${e.name}"`:"an anonymous function";if(Array.isArray(e))return`an array of ${e.length} item(s)`;if(isRecord(e)){let t=Object.keys(e);return t.length>0?`an object with the keys ${t.join(", ")}`:"an empty object"}return`the ${typeof e} ${JSON.stringify(e)}`})(r)}. Every file in this folder is loaded by convention, so each one must default-export that shape. ${t.fix}`);export const resolveListModule=(e,t,r)=>{let o=Array.isArray(e.exports)?e.exports:[e.exports],n=[];for(let i of o){if(!r(i))throw createContractError(e.origin,t,i);n.push(i)}return n};let r=e=>isRecord(e)&&"function"==typeof e.evaluate,o=e=>isRecord(e)&&Object.values(e).every(r),n=e=>"function"==typeof e;export const resolveExpressionModules=(t,r)=>{let n=new Map;return t.map(t=>{let i;if(i=t.exports,!(isRecord(i)&&Object.values(i).every(o)))throw createContractError(t.origin,e,t.exports);for(let[e,o]of Object.entries(t.exports))for(let i of r[e]??[e])for(let e of Object.keys(o)){let r=`${i}.${e}`,o=n.get(r);if(void 0!==o&&o!==t.origin)throw Error(`Duplicate expression ${r}: it is defined in both ${o} and ${t.origin}, which would make its value depend on file order. Keep one definition and remove the other.`);n.set(r,t.origin)}return{origin:t.origin,expressions:t.exports}})};export const resolveActionModules=e=>e.reduce((e,r)=>{let o;if(o=r.exports,!(isRecord(o)&&Object.values(o).every(n)))throw createContractError(r.origin,t,r.exports);return{...e,...r.exports}},{});

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

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

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

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

@@ -1,14 +0,0 @@
-import type { DomainEntity, DomainEntityId, DomainEntityReflection, RawAliasReflection } from '../core/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;
-export declare const createSingleReferenceWrite: <TARGET extends DomainEntity<string>>(targetReflection: DomainEntityReflection<TARGET> | RawAliasReflection<TARGET>, field: string) => (writableState: ReferenceComponentState) => {
-    [x: string]: DomainEntityId<string> | null;
-};
-export declare const createMultipleReferenceRead: <TARGET extends DomainEntity<string>>(_targetReflection: DomainEntityReflection<TARGET> | RawAliasReflection<TARGET>, field: string) => (self: object, state: unknown, ctx: unknown) => ReferenceComponentState;
-export declare const createMultipleReferenceWrite: <TARGET extends DomainEntity<string>>(targetReflection: DomainEntityReflection<TARGET> | RawAliasReflection<TARGET>, field: string) => (writableState: ReferenceComponentState) => {
-    [x: string]: readonly DomainEntityId<string>[];
-};
-export declare const createSingleCompositionRead: (relationName: string) => (self: object, state: unknown, ctx: unknown) => ComposedOfComponentState;
-export declare const createMultipleCompositionRead: (relationName: string) => (self: object, state: unknown, ctx: unknown) => ComposedOfComponentState;
-export declare const createEmptyWrite: () => () => {};

package/dist/domain/relations/component-factories.js

@@ -1 +0,0 @@
-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/composed-of.d.ts

@@ -1,12 +0,0 @@
-import { type DomainEntityId } from '../core/index.js';
-export type ComposedOfComponentState = {
-    /**
-     * List of entity IDs that the parent entity is composed of
-     */
-    readonly childEntityIds: ReadonlyArray<DomainEntityId<string>>;
-};
-/**
- * Defines a general composition of entities with no specific rules.
- */
-export declare const composedOfComponent: import("../index.js").SystemComponentType<"composedOf", ComposedOfComponentState, never>;
-export type ComposedOfComponent = typeof composedOfComponent;

package/dist/domain/relations/composed-of.js

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

package/dist/domain/relations/direct-relation.d.ts

@@ -1,27 +0,0 @@
-import type { DomainEntity, ExpandAlias, ExpressionMeta, TypeOrAlias } from '../core/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>> {
-    kind: 'direct';
-    target: TARGET;
-    field: ArrayReferenceField<ExpandAlias<ENTITIES, ALIASES, SELF>, ExpandAlias<ENTITIES, ALIASES, TARGET>>;
-    cardinality: '0-N' | '1-N';
-    meta?: ExpressionMeta;
-}
-interface DirectSingle1Relation<ENTITIES extends DomainEntity<string>, ALIASES extends Record<string, ENTITIES>, SELF extends TypeOrAlias<ENTITIES, ALIASES>, TARGET extends TypeOrAlias<ENTITIES, ALIASES>> {
-    kind: 'direct';
-    target: TARGET;
-    field: SingleReferenceField<ExpandAlias<ENTITIES, ALIASES, SELF>, ExpandAlias<ENTITIES, ALIASES, TARGET>, never>;
-    cardinality: '1-1';
-    meta?: ExpressionMeta;
-}
-interface DirectSingle0Relation<ENTITIES extends DomainEntity<string>, ALIASES extends Record<string, ENTITIES>, SELF extends TypeOrAlias<ENTITIES, ALIASES>, TARGET extends TypeOrAlias<ENTITIES, ALIASES>> {
-    kind: 'direct';
-    target: TARGET;
-    field: SingleReferenceField<ExpandAlias<ENTITIES, ALIASES, SELF>, ExpandAlias<ENTITIES, ALIASES, TARGET>, null>;
-    cardinality: '0-1';
-    meta?: ExpressionMeta;
-}
-export type DirectRelation<ENTITIES extends DomainEntity<string>, ALIASES extends Record<string, ENTITIES>, SELF extends TypeOrAlias<ENTITIES, ALIASES>, TARGET extends TypeOrAlias<ENTITIES, ALIASES>> = DirectArrayRelation<ENTITIES, ALIASES, SELF, TARGET> | DirectSingle1Relation<ENTITIES, ALIASES, SELF, TARGET> | DirectSingle0Relation<ENTITIES, ALIASES, SELF, TARGET>;
-export declare const directRelation: RelationImplementation<'direct'>;
-export {};

package/dist/domain/relations/indirect-relation.d.ts

@@ -1,78 +0,0 @@
-import { type AliasMap, type DomainEntity, type DomainEntityId, type DomainState, type ExpandAlias, type ExpressionMeta, type TypeOrAlias } from '../core/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';
-    target: TARGET;
-    field: SingleReferenceField<ExpandAlias<ENTITIES, ALIASES, TARGET>, ExpandAlias<ENTITIES, ALIASES, SELF>, null>;
-    cardinality: '0-1';
-    meta?: ExpressionMeta;
-}
-interface IndirectNonNullableSingle0Relation<ENTITIES extends DomainEntity<string>, ALIASES extends Record<string, ENTITIES>, SELF extends TypeOrAlias<ENTITIES, ALIASES>, TARGET extends TypeOrAlias<ENTITIES, ALIASES>> {
-    kind: 'indirect';
-    target: TARGET;
-    field: SingleReferenceField<ExpandAlias<ENTITIES, ALIASES, TARGET>, ExpandAlias<ENTITIES, ALIASES, SELF>, never>;
-    cardinality: '0-1';
-    meta?: ExpressionMeta;
-}
-interface IndirectNullableSingle1Relation<ENTITIES extends DomainEntity<string>, ALIASES extends Record<string, ENTITIES>, SELF extends TypeOrAlias<ENTITIES, ALIASES>, TARGET extends TypeOrAlias<ENTITIES, ALIASES>> {
-    kind: 'indirect';
-    target: TARGET;
-    field: SingleReferenceField<ExpandAlias<ENTITIES, ALIASES, TARGET>, ExpandAlias<ENTITIES, ALIASES, SELF>, null>;
-    cardinality: '1-1';
-    meta?: ExpressionMeta;
-}
-interface IndirectNonNullableSingle1Relation<ENTITIES extends DomainEntity<string>, ALIASES extends Record<string, ENTITIES>, SELF extends TypeOrAlias<ENTITIES, ALIASES>, TARGET extends TypeOrAlias<ENTITIES, ALIASES>> {
-    kind: 'indirect';
-    target: TARGET;
-    field: SingleReferenceField<ExpandAlias<ENTITIES, ALIASES, TARGET>, ExpandAlias<ENTITIES, ALIASES, SELF>, never>;
-    cardinality: '1-1';
-    meta?: ExpressionMeta;
-}
-interface IndirectSingleNRelation<ENTITIES extends DomainEntity<string>, ALIASES extends Record<string, ENTITIES>, SELF extends TypeOrAlias<ENTITIES, ALIASES>, TARGET extends TypeOrAlias<ENTITIES, ALIASES>> {
-    kind: 'indirect';
-    target: TARGET;
-    field: SingleReferenceField<ExpandAlias<ENTITIES, ALIASES, TARGET>, ExpandAlias<ENTITIES, ALIASES, SELF>, never>;
-    cardinality: '0-N' | '1-N';
-    meta?: ExpressionMeta;
-}
-interface IndirectNullableSingleNRelation<ENTITIES extends DomainEntity<string>, ALIASES extends Record<string, ENTITIES>, SELF extends TypeOrAlias<ENTITIES, ALIASES>, TARGET extends TypeOrAlias<ENTITIES, ALIASES>> {
-    kind: 'indirect';
-    target: TARGET;
-    field: SingleReferenceField<ExpandAlias<ENTITIES, ALIASES, TARGET>, ExpandAlias<ENTITIES, ALIASES, SELF>, null>;
-    cardinality: '0-N' | '1-N';
-    meta?: ExpressionMeta;
-}
-interface IndirectArray0Relation<ENTITIES extends DomainEntity<string>, ALIASES extends Record<string, ENTITIES>, SELF extends TypeOrAlias<ENTITIES, ALIASES>, TARGET extends TypeOrAlias<ENTITIES, ALIASES>> {
-    kind: 'indirect';
-    target: TARGET;
-    field: ArrayReferenceField<ExpandAlias<ENTITIES, ALIASES, TARGET>, ExpandAlias<ENTITIES, ALIASES, SELF>>;
-    cardinality: '0-1';
-    meta?: ExpressionMeta;
-}
-interface IndirectArray1Relation<ENTITIES extends DomainEntity<string>, ALIASES extends Record<string, ENTITIES>, SELF extends TypeOrAlias<ENTITIES, ALIASES>, TARGET extends TypeOrAlias<ENTITIES, ALIASES>> {
-    kind: 'indirect';
-    target: TARGET;
-    field: ArrayReferenceField<ExpandAlias<ENTITIES, ALIASES, TARGET>, ExpandAlias<ENTITIES, ALIASES, SELF>>;
-    cardinality: '1-1';
-    meta?: ExpressionMeta;
-}
-interface IndirectArrayNRelation<ENTITIES extends DomainEntity<string>, ALIASES extends Record<string, ENTITIES>, SELF extends TypeOrAlias<ENTITIES, ALIASES>, TARGET extends TypeOrAlias<ENTITIES, ALIASES>> {
-    kind: 'indirect';
-    target: TARGET;
-    field: ArrayReferenceField<ExpandAlias<ENTITIES, ALIASES, TARGET>, ExpandAlias<ENTITIES, ALIASES, SELF>>;
-    cardinality: '0-N' | '1-N';
-    meta?: ExpressionMeta;
-}
-export type IndirectRelation<ENTITIES extends DomainEntity<string>, ALIASES extends Record<string, ENTITIES>, SELF extends TypeOrAlias<ENTITIES, ALIASES>, TARGET extends TypeOrAlias<ENTITIES, ALIASES>> = IndirectArray1Relation<ENTITIES, ALIASES, SELF, TARGET> | IndirectArray0Relation<ENTITIES, ALIASES, SELF, TARGET> | IndirectArrayNRelation<ENTITIES, ALIASES, SELF, TARGET> | IndirectNullableSingle0Relation<ENTITIES, ALIASES, SELF, TARGET> | IndirectNonNullableSingle0Relation<ENTITIES, ALIASES, SELF, TARGET> | IndirectNullableSingle1Relation<ENTITIES, ALIASES, SELF, TARGET> | IndirectNonNullableSingle1Relation<ENTITIES, ALIASES, SELF, TARGET> | IndirectSingleNRelation<ENTITIES, ALIASES, SELF, TARGET> | IndirectNullableSingleNRelation<ENTITIES, ALIASES, SELF, TARGET>;
-/**
- * Resolves `indirect` relations from a per-state reverse-reference index. Relations reading the
- * same field on the same set of target types share one index mapping each referenced id to the
- * entities that reference it; the first resolution on a state walks the entities once to fill
- * every index, and every later resolution on that state is a lookup. Registration closes once the
- * first state has been indexed, so an index can never be missing from a state already walked.
- */
-export declare const createIndirectRelation: <ENTITIES extends DomainEntity<string>, ALIASES extends Record<string, ENTITIES>>(aliasMap: AliasMap<ALIASES>) => (relation: {
-    readonly target: TypeOrAlias<ENTITIES, ALIASES>;
-    readonly field: string;
-}) => (sourceId: DomainEntityId<string>, state: DomainState<ENTITIES>) => DomainEntityId<string>[];
-export {};

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

@@ -1 +0,0 @@
-import{isArray as e}from"@salsita-ai/common/utils";import{expandAlias as t}from"../core/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/reference-component.d.ts

@@ -1,16 +0,0 @@
-import { type $DomainEntity, type DomainComponentOpticBuilder, type DomainEntity, type DomainEntityId, type DomainEntityReflection, type RawAliasReflection } from '../core/index.js';
-import type { ArrayReferenceField, SingleReferenceField } from './reference-field.js';
-export type ReferenceComponentState = {
-    /**
-     * List of entity IDs that the relation is referencing
-     */
-    readonly referencedEntityIds: ReadonlyArray<DomainEntityId<string>>;
-};
-/**
- * Component used for working with relational data in system features. All generated relations create matching reference components that
- * can be used to update the relations on any crud operations.
- */
-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("../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/relations/reference-component.js

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

package/dist/domain/relations/reference-field.d.ts

@@ -1,7 +0,0 @@
-import type { DomainEntity } from '../core/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];
-export type ArrayReferenceField<FROM extends DomainEntity<string>, TO extends DomainEntity<string>> = {
-    [K in keyof FROM]: ReadonlyArray<TO['id']> extends FROM[K] ? FROM[K] extends ReadonlyArray<TO['id']> ? K & string : never : never;
-}[keyof FROM];

package/dist/domain/relations/relation-factory.d.ts

@@ -1,17 +0,0 @@
-import type { $DomainEntity, AliasMap, AnonymousExpression, DomainEntity, ExpandAlias, TypeOrAlias } from '../core/index.js';
-import { type AllOfTypeRelation } from './all-of-type-relation.js';
-import type { DirectRelation } from './direct-relation.js';
-import { type IndirectRelation } from './indirect-relation.js';
-export type Relation<ENTITIES extends DomainEntity<string>, ALIASES extends Record<string, ENTITIES>, SELF extends TypeOrAlias<ENTITIES, ALIASES>, TARGET extends TypeOrAlias<ENTITIES, ALIASES>> = DirectRelation<ENTITIES, ALIASES, SELF, TARGET> | AllOfTypeRelation<ENTITIES, ALIASES, TARGET> | IndirectRelation<ENTITIES, ALIASES, SELF, TARGET>;
-export interface RelationFactory<ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, $MAP extends Record<TypeOrAlias<ENTITIES, ALIASES>, $DomainEntity<ENTITIES>>, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, ALIASES extends Record<string, ENTITIES>> {
-    <SELF extends TypeOrAlias<ENTITIES, ALIASES>, TARGET extends TypeOrAlias<ENTITIES, ALIASES>>(relation: Extract<Relation<ENTITIES, ALIASES, SELF, TARGET>, {
-        cardinality: '0-1';
-    }>): AnonymousExpression<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ExpandAlias<ENTITIES, ALIASES, SELF>, $MAP[TARGET] | null>;
-    <SELF extends TypeOrAlias<ENTITIES, ALIASES>, TARGET extends TypeOrAlias<ENTITIES, ALIASES>>(relation: Extract<Relation<ENTITIES, ALIASES, SELF, TARGET>, {
-        cardinality: '1-1';
-    }>): AnonymousExpression<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ExpandAlias<ENTITIES, ALIASES, SELF>, $MAP[TARGET]>;
-    <SELF extends TypeOrAlias<ENTITIES, ALIASES>, TARGET extends TypeOrAlias<ENTITIES, ALIASES>>(relation: Extract<Relation<ENTITIES, ALIASES, SELF, TARGET>, {
-        cardinality: '0-N' | '1-N';
-    }>): AnonymousExpression<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ExpandAlias<ENTITIES, ALIASES, SELF>, ReadonlyArray<$MAP[TARGET]>>;
-}
-export declare const createRelationFactory: <ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, $MAP extends Record<TypeOrAlias<ENTITIES, ALIASES>, $DomainEntity<ENTITIES>>, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, ALIASES extends Record<string, ENTITIES>>(aliasMap: AliasMap<ALIASES>) => RelationFactory<ENTITIES, ALLOWED_ROOT_ENTITIES, $MAP, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ALIASES>;

package/dist/domain/relations/relation-factory.js

@@ -1 +0,0 @@
-import{match as t}from"ts-pattern";import{createAllOfTypeRelation as e}from"./all-of-type-relation.js";import{directRelation as r}from"./direct-relation.js";import{createIndirectRelation as i}from"./indirect-relation.js";export const createRelationFactory=n=>{let a=e(n),o=i(n);return e=>{let i=t(e).with({kind:"direct"},t=>r(t,n)).with({kind:"indirect"},t=>o(t)).with({kind:"allOfType"},t=>a(t)).exhaustive(),l=t(e).with({cardinality:"0-1"},()=>t=>{if(t.length>1)throw Error(`Expected at most one entity, but got ${t.length}`);return t.length>0?t[0]:null}).with({cardinality:"1-1"},()=>t=>{if(1!==t.length)throw Error(`Expected exactly one entity, but got ${t.length}`);return t[0]}).with({cardinality:"0-N"},()=>t=>t).with({cardinality:"1-N"},()=>t=>{if(0===t.length)throw Error("Expected at least one entity, but got none");return t}).exhaustive();return{meta:{alwaysEvaluate:!0,...e.meta},evaluate:(t,r,a)=>{let o=i(t,r,a.domain),d=a.domain.get$Entities(o,r);if(!d.every(t=>e.target in n?n[e.target].includes(t.type):t.type===e.target)){let t=d.map(t=>t.type).filter(t=>e.target in n?n[e.target].includes(t):t===e.target);throw Error(`Expected ${e.target} entities, but got ${t.join(", ")}`)}return l(d)}}}};

package/dist/domain/relations/relation-implementation.d.ts

@@ -1,5 +0,0 @@
-import type { AliasMap, Domain, DomainEntity, DomainEntityId, DomainState } from '../core/index.js';
-import type { Relation } from './relation-factory.js';
-export type RelationImplementation<KIND extends Relation<any, any, any, any>['kind']> = (relation: Extract<Relation<any, any, any, any>, {
-    kind: KIND;
-}>, aliasMap: AliasMap<Record<string, DomainEntity<string>>>) => (selfId: DomainEntityId<string>, state: DomainState<DomainEntity<string>>, domain: Domain<any, any, any>) => Array<DomainEntityId<string>>;

package/dist/domain/system-components/attribute-switch.d.ts

@@ -1,8 +0,0 @@
-export declare const AttributeSwitchValueSchema: {
-    readonly type: ["string", "number", "boolean"];
-};
-export type AttributeSwitchComponentState = {
-    readonly value: boolean;
-};
-export declare const attributeSwitchComponent: import("../index.js").SystemComponentType<"attributeSwitch", AttributeSwitchComponentState, "value">;
-export type AttributeSwitchComponent = typeof attributeSwitchComponent;

package/dist/domain/system-components/attribute-switch.js

@@ -1 +0,0 @@
-import{SystemComponentBuilder as t}from"../core/index.js";export const AttributeSwitchValueSchema={type:["string","number","boolean"]};export const attributeSwitchComponent=t.component("attributeSwitch").withState({type:"object",properties:{value:AttributeSwitchValueSchema},tsType:"AttributeSwitchComponentState",import:[{module:"@salsita-ai/sdk/domain",member:"AttributeSwitchComponentState"}],required:["value"],additionalProperties:!1}).withWritableKeys(["value"]).build();

package/dist/domain/system-components/canvas-config.d.ts

@@ -1,87 +0,0 @@
-import { type ComponentInstance, type ComponentSnapshot } from '../core/index.js';
-export type CanvasConfigComponentState = {
-    /**
-     * If true, highlighting will be disabled.
-     */
-    readonly highlightingDisabled?: boolean;
-    /**
-     * Frameloop mode for the canvas.
-     */
-    readonly frameloop?: 'always' | 'demand' | 'never';
-    /**
-     * **Temporary workaround for Ambient Occlusion issues.** Do not use, unless you know you need this.
-     *
-     * If `true`, the canvas environment will not be wrapped in `Suspense`.
-     */
-    readonly __doNotSuspendEnvironment?: boolean;
-    /**
-     * shader precision. Can be "highp", "mediump" or "lowp".
-     */
-    readonly precision?: 'highp' | 'mediump' | 'lowp';
-    /**
-     * default is false.
-     */
-    readonly alpha?: boolean | undefined;
-    /**
-     * default is true.
-     */
-    readonly premultipliedAlpha?: boolean | undefined;
-    /**
-     * default is false.
-     */
-    readonly antialias?: boolean | undefined;
-    /**
-     * default is true.
-     */
-    readonly stencil?: boolean | undefined;
-    /**
-     * default is false.
-     */
-    readonly preserveDrawingBuffer?: boolean | undefined;
-    /**
-     * Can be "high-performance", "low-power" or "default"
-     */
-    readonly powerPreference?: string | undefined;
-    /**
-     * default is true.
-     */
-    readonly depth?: boolean | undefined;
-    /**
-     * default is false.
-     */
-    readonly logarithmicDepthBuffer?: boolean | undefined;
-    /**
-     * default is false.
-     */
-    readonly failIfMajorPerformanceCaveat?: boolean | undefined;
-    /**
-     * Shadows config for the canvas. Can be "basic", "percentage", "soft" or "variance".
-     */
-    readonly shadows?: 'basic' | 'percentage' | 'soft' | 'variance';
-    /**
-     * When true, uses an optimized emissive-based highlight instead of the default clone-based highlight.
-     * This modifies material emissive properties directly rather than cloning geometry.
-     *
-     * When enabled, the clone-based highlight is automatically disabled.
-     * Fast highlight works even when `highlightingDisabled` is true.
-     */
-    readonly enableFastHighlight?: boolean;
-    /**
-     * Color for the fast emissive highlight effect. Accepts any CSS color string.
-     * Only applies when `enableFastHighlight` is true.
-     * @default 'white'
-     */
-    readonly fastHighlightColor?: string;
-    /**
-     * Intensity of the fast emissive highlight effect (0-1 range).
-     * Only applies when `enableFastHighlight` is true.
-     * @default 0.1
-     */
-    readonly fastHighlightIntensity?: number;
-};
-export declare const canvasConfigComponent: import("../index.js").SystemComponentType<"canvasConfig", CanvasConfigComponentState, never>;
-export type CanvasConfigComponent = typeof canvasConfigComponent;
-export type CanvasConfigComponentInstance = ComponentInstance<CanvasConfigComponent>;
-export type CanvasConfigComponentSnapshot = ComponentSnapshot<CanvasConfigComponent>;
-export declare const isCanvasConfigSnapshot: (snapshot: ComponentSnapshot<import("../index.js").SystemComponentTypeConstraint>) => snapshot is ComponentSnapshot<import("../index.js").SystemComponentType<"canvasConfig", CanvasConfigComponentState, never>>;
-export declare const isCanvasConfigInstance: (instance: ComponentInstance<import("../index.js").SystemComponentTypeConstraint>) => instance is ComponentInstance<import("../index.js").SystemComponentType<"canvasConfig", CanvasConfigComponentState, never>>;