@salsita-ai/sdk 0.50.0-develop.6d8967bc99 → 0.50.0-develop.6fc83d7732

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

@@ -1,66 +0,0 @@
-import type { ExtendedJsonSchema } from '@salsita-ai/common/utils';
-import type { DomainContextSystems } from '../domain-context/domain-context-systems.js';
-import type { StateUpdate, UpdateFactory } from './component/index.js';
-import type { ExpressionContext } from './expression/index.js';
-import type { $DomainEntity, DomainEntity } from './model/index.js';
-import type { DomainState, IdSequence } from './state/index.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 `DomainBuilder.withActionModules` 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/expression/memoize-expression.d.ts

@@ -1,17 +0,0 @@
-import type { DomainEntity, DomainEntityId } from '../model/index.js';
-import type { Expression, ExpressionOrigin } from './expression.js';
-export interface ExpressionTrace {
-    origin: ExpressionOrigin;
-    entityId: DomainEntityId<string>;
-}
-export declare const traceToString: (trace: ExpressionTrace) => string;
-export declare class ExpressionEvaluationError extends Error {
-    readonly _tag = "expression-evaluation-error";
-    constructor(trace: ExpressionTrace, error: any);
-}
-export declare class CircularDependencyError extends Error {
-    readonly _tag = "circular-dependency-error";
-    readonly path: ExpressionTrace[];
-    constructor(trace: ExpressionTrace, cause?: CircularDependencyError);
-}
-export declare const memoizeExpression: <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>(expression: Expression<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, SELF, T>) => Expression<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, SELF, T>;

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

@@ -1,16 +0,0 @@
-import type { AnyExpressions } from './expression.js';
-interface DomainExpressionsSource {
-    readonly expressions: AnyExpressions;
-    readonly $entityReflections: Record<string, {
-        readonly expressions: readonly string[];
-    }>;
-}
-/**
- * Derives the runnable expression table from the factory's spec data: validates the declared
- * (reflection) expressions against the implemented ones — missing implementations throw, extra
- * ones log — and wraps every expression in the per-state memoization. Pure with respect to its
- * input, so it can back a registry selector keyed on the factory identity: a hot-reloaded factory
- * produces a fresh table, an unchanged one keeps the memoized result.
- */
-export declare const prepareDomainExpressions: (source: DomainExpressionsSource) => AnyExpressions;
-export {};

package/dist/domain/domain-context/recipe-system/recipes.d.ts

@@ -1,55 +0,0 @@
-import type { OmitEmpty, OmitNever, UnionToIntersection } from '@salsita-ai/common/utils';
-import { type AliasMap, type DomainEntity, type DomainEntityId, type DomainEntityReflection, type EntityByType, type EventualAlias, type ExpandAlias, type ExtractFromAliasedRecord, type TypeOrAlias } from '../../core/index.js';
-export type EntityDefaults<ENTITY extends DomainEntity<string>> = {
-    [K in Exclude<keyof ENTITY, 'id' | 'type'>]: ENTITY[K] extends DomainEntityId<any> ? null : ENTITY[K];
-};
-export type EntityRecipe<ENTITY extends DomainEntity<string>> = ENTITY;
-export type EntityOverrides<ENTITIES extends DomainEntity<string>, TYPE extends ENTITIES['type']> = Partial<Omit<EntityByType<ENTITIES, TYPE>, 'type'>> & {
-    type: TYPE;
-};
-export type DeclaredEntitiesDefaults<ENTITIES extends DomainEntity<string>> = {
-    [K in ENTITIES['type']]: EntityDefaults<EntityByType<ENTITIES, K>>;
-};
-type ExpandDefaults<ENTITIES extends DomainEntity<string>, ALIASES extends Readonly<Record<string, ENTITIES>>, ALIASED_DEFAULTS extends Partial<Record<TypeOrAlias<ENTITIES, ALIASES>, Record<string, unknown>>>> = {
-    [K in ENTITIES['type']]: ExtractFromAliasedRecord<ENTITIES, ALIASES, ALIASED_DEFAULTS, EventualAlias<ENTITIES, ALIASES, K> | K> extends infer DEFAULTS_FROM_ALIAS ? [
-        DEFAULTS_FROM_ALIAS
-    ] extends [never] ? Record<never, never> : unknown extends UnionToIntersection<DEFAULTS_FROM_ALIAS> ? never : UnionToIntersection<DEFAULTS_FROM_ALIAS> : never;
-};
-export type AliasedEntitiesDefaults<ENTITIES extends DomainEntity<string>, ALIASES extends Readonly<Record<string, ENTITIES>>> = {
-    [K in TypeOrAlias<ENTITIES, ALIASES>]?: Partial<EntityDefaults<ExpandAlias<ENTITIES, ALIASES, K>>>;
-};
-export type RecipeFactory<ENTITIES extends DomainEntity<string>> = <TYPE extends ENTITIES['type']>(overrides: EntityOverrides<ENTITIES, TYPE>) => EntityRecipe<EntityByType<ENTITIES, TYPE>>;
-type ConflictingDefaults<PROVIDED extends Record<string, Record<string, unknown>>, EXPECTED extends Record<string, Record<string, unknown>>> = OmitEmpty<OmitNever<{
-    [TYPE in keyof PROVIDED | keyof EXPECTED]: TYPE extends keyof EXPECTED ? TYPE extends keyof PROVIDED ? PROVIDED[TYPE] extends EXPECTED[TYPE] ? never : OmitNever<Exclude<EXPECTED[TYPE], PROVIDED[TYPE]>> : EXPECTED[TYPE] : never;
-}>>;
-type Build<ENTITIES extends DomainEntity<string>, PROVIDED extends Record<string, Record<string, unknown>>, EXPECTED extends Record<string, Record<string, unknown>>> = Record<string, never> extends ConflictingDefaults<PROVIDED, EXPECTED> ? {
-    build: () => RecipeFactory<ENTITIES>;
-} : {
-    /**
-     * DO NOT USE in runtime!
-     *
-     * This is just a dev-time tool to review which defaults you forgot to provide.
-     * Use your IDEs code-completion to see which entities have missing expressions
-     * and which expressions these are.
-     *
-     * Use the helper when you see the following error on the `.build()` method call:
-     * ```
-     * TS2349: This expression is not callable.
-     * Type never has no call signatures.
-     * ```
-     * simply
-     * ```ts
-     *   .withDefaults({...})
-     *   ._conflicts.Oven. // <- trigger code-completion here
-     * ```
-     */
-    _conflicts: ConflictingDefaults<PROVIDED, EXPECTED>;
-};
-export declare const RecipeFactoryBuilder: {
-    forAliases: <ENTITIES extends DomainEntity<string>, ALIASES extends Record<string, ENTITIES>>(aliasMap: AliasMap<ALIASES>) => {
-        forEntities: (entityReflections: ReadonlyArray<ENTITIES extends any ? DomainEntityReflection<ENTITIES> : never>) => {
-            withDefaults: <ALIASED_DEFAULTS extends AliasedEntitiesDefaults<ENTITIES, ALIASES>>(entitiesDefaults: ALIASED_DEFAULTS) => Build<ENTITIES, ExpandDefaults<ENTITIES, ALIASES, ALIASED_DEFAULTS>, DeclaredEntitiesDefaults<ENTITIES>>;
-        };
-    };
-};
-export {};

package/dist/domain/domain-context/recipe-system/recipes.js

@@ -1 +0,0 @@
-import{_unsafeBuildDomainEntityId as e,expandAlias as r}from"../../core/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/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>>;

package/dist/domain/system-components/child-entity-recipe-hierarchy.d.ts

@@ -1,21 +0,0 @@
-import { type ComponentInstance, type ComponentSnapshot, type SystemComponentTypeConstraint } from '../core/index.js';
-import { type GroupedRecipeItems } from './common/recipes.js';
-export type ChildEntityRecipeHierarchyComponentState = {
-    /**
-     * The fixable violations.
-     */
-    readonly fixableViolations?: readonly string[];
-    /**
-     * The recipes to display. Can be a group of recipes or a list of recipes.
-     */
-    readonly recipes: GroupedRecipeItems;
-};
-/**
- * Defines a hierarhcy of recipes that can be added as children of a given entity
- */
-export declare const childEntityRecipeHierarchyComponent: import("../index.js").SystemComponentType<"childEntityRecipeHierarchy", ChildEntityRecipeHierarchyComponentState, never>;
-export type ChildEntityRecipeHierarchyComponent = typeof childEntityRecipeHierarchyComponent;
-export type ChildEntityRecipeHierarchyComponentSnapshot = ComponentSnapshot<typeof childEntityRecipeHierarchyComponent>;
-export type ChildEntityRecipeHierarchyComponentInstance = ComponentInstance<typeof childEntityRecipeHierarchyComponent>;
-export declare const isChildEntityRecipeHierarchySnapshot: (snapshot: ComponentSnapshot<SystemComponentTypeConstraint>) => snapshot is ChildEntityRecipeHierarchyComponentSnapshot;
-export declare const isChildEntityRecipeHierarchyInstance: (instance: ComponentInstance<SystemComponentTypeConstraint>) => instance is ChildEntityRecipeHierarchyComponentInstance;

package/dist/domain/system-components/child-entity-recipe-hierarchy.js

@@ -1 +0,0 @@
-import{SystemComponentBuilder as e}from"../core/index.js";import{GroupedRecipeItemsSchema as i}from"./common/recipes.js";export const childEntityRecipeHierarchyComponent=e.component("childEntityRecipeHierarchy").withState({type:"object",tsType:"ChildEntityRecipeHierarchyComponentState",import:[{module:"@salsita-ai/sdk/domain",member:"ChildEntityRecipeHierarchyComponentState"}],properties:{recipes:i,fixableViolations:{type:"array",items:{type:"string"}}},definitions:{GroupedRecipeItems:i},required:["recipes"],additionalProperties:!1}).build();export const isChildEntityRecipeHierarchySnapshot=e=>e.componentInstance.componentType===childEntityRecipeHierarchyComponent;export const isChildEntityRecipeHierarchyInstance=e=>e.componentType===childEntityRecipeHierarchyComponent;