@almadar/core 10.41.0 → 10.43.0

package/dist/{effect-DSbx6joe.d.ts → effect-NbTgX2yB.d.ts}

@@ -1,6 +1,5 @@
 import { z } from 'zod';
-import { S as SExpr, a as EventPayload, E as Expression } from './expression-DpAj1RzP.js';
-import { F as FieldValue, b as EntityRow } from './entity-DfD-iXkn.js';
+import { J as JsonValue, R as RuntimeValue, S as SExpr, a as EventPayload, E as Expression } from './expression-Yf7qvvOs.js';
 
 /**
  * Service Types for Orbital Schema
@@ -74,12 +73,12 @@ declare const RestAuthConfigSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     type: "api-key" | "bearer" | "basic" | "oauth2";
     keyName?: string | undefined;
-    location?: "query" | "header" | undefined;
+    location?: "header" | "query" | undefined;
     secretEnv?: string | undefined;
 }, {
     type: "api-key" | "bearer" | "basic" | "oauth2";
     keyName?: string | undefined;
-    location?: "query" | "header" | undefined;
+    location?: "header" | "query" | undefined;
     secretEnv?: string | undefined;
 }>;
 declare const RestServiceDefSchema: z.ZodObject<{
@@ -96,12 +95,12 @@ declare const RestServiceDefSchema: z.ZodObject<{
     }, "strip", z.ZodTypeAny, {
         type: "api-key" | "bearer" | "basic" | "oauth2";
         keyName?: string | undefined;
-        location?: "query" | "header" | undefined;
+        location?: "header" | "query" | undefined;
         secretEnv?: string | undefined;
     }, {
         type: "api-key" | "bearer" | "basic" | "oauth2";
         keyName?: string | undefined;
-        location?: "query" | "header" | undefined;
+        location?: "header" | "query" | undefined;
         secretEnv?: string | undefined;
     }>>;
     timeout: z.ZodOptional<z.ZodNumber>;
@@ -110,26 +109,26 @@ declare const RestServiceDefSchema: z.ZodObject<{
     name: string;
     baseUrl: string;
     description?: string | undefined;
-    headers?: Record<string, string> | undefined;
     auth?: {
         type: "api-key" | "bearer" | "basic" | "oauth2";
         keyName?: string | undefined;
-        location?: "query" | "header" | undefined;
+        location?: "header" | "query" | undefined;
         secretEnv?: string | undefined;
     } | undefined;
+    headers?: Record<string, string> | undefined;
     timeout?: number | undefined;
 }, {
     type: "rest";
     name: string;
     baseUrl: string;
     description?: string | undefined;
-    headers?: Record<string, string> | undefined;
     auth?: {
         type: "api-key" | "bearer" | "basic" | "oauth2";
         keyName?: string | undefined;
-        location?: "query" | "header" | undefined;
+        location?: "header" | "query" | undefined;
         secretEnv?: string | undefined;
     } | undefined;
+    headers?: Record<string, string> | undefined;
     timeout?: number | undefined;
 }>;
 /**
@@ -312,12 +311,12 @@ declare const ServiceDefinitionSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObj
     }, "strip", z.ZodTypeAny, {
         type: "api-key" | "bearer" | "basic" | "oauth2";
         keyName?: string | undefined;
-        location?: "query" | "header" | undefined;
+        location?: "header" | "query" | undefined;
         secretEnv?: string | undefined;
     }, {
         type: "api-key" | "bearer" | "basic" | "oauth2";
         keyName?: string | undefined;
-        location?: "query" | "header" | undefined;
+        location?: "header" | "query" | undefined;
         secretEnv?: string | undefined;
     }>>;
     timeout: z.ZodOptional<z.ZodNumber>;
@@ -326,26 +325,26 @@ declare const ServiceDefinitionSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObj
     name: string;
     baseUrl: string;
     description?: string | undefined;
-    headers?: Record<string, string> | undefined;
     auth?: {
         type: "api-key" | "bearer" | "basic" | "oauth2";
         keyName?: string | undefined;
-        location?: "query" | "header" | undefined;
+        location?: "header" | "query" | undefined;
         secretEnv?: string | undefined;
     } | undefined;
+    headers?: Record<string, string> | undefined;
     timeout?: number | undefined;
 }, {
     type: "rest";
     name: string;
     baseUrl: string;
     description?: string | undefined;
-    headers?: Record<string, string> | undefined;
     auth?: {
         type: "api-key" | "bearer" | "basic" | "oauth2";
         keyName?: string | undefined;
-        location?: "query" | "header" | undefined;
+        location?: "header" | "query" | undefined;
         secretEnv?: string | undefined;
     } | undefined;
+    headers?: Record<string, string> | undefined;
     timeout?: number | undefined;
 }>, z.ZodObject<{
     name: z.ZodString;
@@ -527,12 +526,12 @@ declare const ServiceRefSchema: z.ZodUnion<[z.ZodDiscriminatedUnion<"type", [z.Z
     }, "strip", z.ZodTypeAny, {
         type: "api-key" | "bearer" | "basic" | "oauth2";
         keyName?: string | undefined;
-        location?: "query" | "header" | undefined;
+        location?: "header" | "query" | undefined;
         secretEnv?: string | undefined;
     }, {
         type: "api-key" | "bearer" | "basic" | "oauth2";
         keyName?: string | undefined;
-        location?: "query" | "header" | undefined;
+        location?: "header" | "query" | undefined;
         secretEnv?: string | undefined;
     }>>;
     timeout: z.ZodOptional<z.ZodNumber>;
@@ -541,26 +540,26 @@ declare const ServiceRefSchema: z.ZodUnion<[z.ZodDiscriminatedUnion<"type", [z.Z
     name: string;
     baseUrl: string;
     description?: string | undefined;
-    headers?: Record<string, string> | undefined;
     auth?: {
         type: "api-key" | "bearer" | "basic" | "oauth2";
         keyName?: string | undefined;
-        location?: "query" | "header" | undefined;
+        location?: "header" | "query" | undefined;
         secretEnv?: string | undefined;
     } | undefined;
+    headers?: Record<string, string> | undefined;
     timeout?: number | undefined;
 }, {
     type: "rest";
     name: string;
     baseUrl: string;
     description?: string | undefined;
-    headers?: Record<string, string> | undefined;
     auth?: {
         type: "api-key" | "bearer" | "basic" | "oauth2";
         keyName?: string | undefined;
-        location?: "query" | "header" | undefined;
+        location?: "header" | "query" | undefined;
         secretEnv?: string | undefined;
     } | undefined;
+    headers?: Record<string, string> | undefined;
     timeout?: number | undefined;
 }>, z.ZodObject<{
     name: z.ZodString;
@@ -746,13 +745,1517 @@ type ServiceParams = {
     [key: string]: ServiceParamsValue;
 };
 
+/**
+ * Identity model (Almadar Rabit V4, Phase 1 — types only).
+ *
+ * Branded, prefix-tagged node ids + a workspace-scoped name ledger. Ids are
+ * the durable edge keys of the identity-keyed schema graph; the ledger is the
+ * sole name↔id map (names are display labels, one row per rename). This module
+ * is pure: no I/O, no side effects. Minting is the only impurity (clock +
+ * crypto randomness for the ULID suffix).
+ *
+ * @packageDocumentation
+ */
+
+type Branded<K extends string> = string & {
+    readonly __idBrand: K;
+};
+type OrbitalId = Branded<'OrbitalId'>;
+type EntityId = Branded<'EntityId'>;
+type TraitId = Branded<'TraitId'>;
+type EventId = Branded<'EventId'>;
+type PageId = Branded<'PageId'>;
+type ServiceId = Branded<'ServiceId'>;
+type ThemeId = Branded<'ThemeId'>;
+type PaletteEntryId = Branded<'PaletteEntryId'>;
+/** Node kind ↔ id-prefix table. The single source of truth for every prefix. */
+declare const ID_PREFIXES: {
+    readonly orbital: "orb_";
+    readonly entity: "ent_";
+    readonly trait: "trt_";
+    readonly event: "evt_";
+    readonly page: "pag_";
+    readonly service: "svc_";
+    readonly theme: "thm_";
+    readonly palette: "pal_";
+};
+type IdKind = keyof typeof ID_PREFIXES;
+/** Compile-time map from kind to its branded id type. */
+interface IdForKind {
+    orbital: OrbitalId;
+    entity: EntityId;
+    trait: TraitId;
+    event: EventId;
+    page: PageId;
+    service: ServiceId;
+    theme: ThemeId;
+    palette: PaletteEntryId;
+}
+declare const isOrbitalId: (value: string) => value is OrbitalId;
+declare const asOrbitalId: (value: string) => OrbitalId;
+declare const isEntityId: (value: string) => value is EntityId;
+declare const asEntityId: (value: string) => EntityId;
+declare const isTraitId: (value: string) => value is TraitId;
+declare const asTraitId: (value: string) => TraitId;
+declare const isEventId: (value: string) => value is EventId;
+declare const asEventId: (value: string) => EventId;
+declare const isPageId: (value: string) => value is PageId;
+declare const asPageId: (value: string) => PageId;
+declare const isServiceId: (value: string) => value is ServiceId;
+declare const asServiceId: (value: string) => ServiceId;
+declare const isThemeId: (value: string) => value is ThemeId;
+declare const asThemeId: (value: string) => ThemeId;
+declare const isPaletteEntryId: (value: string) => value is PaletteEntryId;
+declare const asPaletteEntryId: (value: string) => PaletteEntryId;
+/**
+ * The id-prefix for a node kind (`'entity' → 'ent_'`). The JS mirror of the
+ * Rust `IdKind::prefix`. Single source of truth is {@link ID_PREFIXES}.
+ */
+declare function idPrefix(kind: IdKind): string;
+/**
+ * The node kind an id's prefix denotes, or `null` for an unrecognized /
+ * bare-prefix string. The JS mirror of the Rust `id_kind_of`. Prefixes are
+ * mutually non-overlapping, so match order is irrelevant.
+ */
+declare function idKindOf(id: string): IdKind | null;
+/** Mint a fresh, opaque, kind-tagged id: `<prefix><ULID>`. */
+declare function mintId<K extends IdKind>(kind: K): IdForKind[K];
+/** Ledger row kind. `palette` entries are manifest ids, not name-ledger rows. */
+type LedgerKind = 'orbital' | 'entity' | 'trait' | 'event' | 'page' | 'service' | 'theme';
+/**
+ * One ledger row: the workspace's name history for a single node id.
+ *
+ * For kind `'event'` the row is minted per-(trait, declared event) per the
+ * Phase-0 freeze — the owning trait is recorded in `parent`; a call-site event
+ * rename is a one-row edit on this same id (the baked-vs-current key namespaces
+ * collapse into `bakedName` vs `curName`).
+ */
+interface LedgerEntry {
+    id: string;
+    kind: LedgerKind;
+    bakedName: string;
+    curName: string;
+    renames: ReadonlyArray<{
+        from: string;
+        to: string;
+        at: string;
+    }>;
+    owner: 'std' | 'io' | 'workspace';
+    /** Owning trait for kind `'event'` (per-trait event-id namespace). */
+    parent?: TraitId;
+}
+interface IdentityLedger {
+    schemaVersion: 1;
+    entries: Record<string, LedgerEntry>;
+}
+/** Resolve a name to its id via exact `curName` match within `kind`, else null. */
+declare function ledgerResolveName(ledger: IdentityLedger, kind: LedgerKind, name: string): string | null;
+/** Immutable rename: returns a new ledger with the id's `curName` + `renames` updated. */
+declare function ledgerRename(ledger: IdentityLedger, id: string, to: string, at: string): IdentityLedger;
+/** Current display name for an id, or null when the id is not in the ledger. */
+declare function ledgerCurName(ledger: IdentityLedger, id: string): string | null;
+/**
+ * Prefix-checked, kind-tagged id schemas. Each narrows a validated string to
+ * its branded id type via the module's own kind guard, so a schema that reads
+ * `TraitIdSchema.optional()` yields `TraitId | undefined` with no cast. The
+ * guard is the single source of prefix truth (`ID_PREFIXES`); the schema is a
+ * thin zod wrapper over it.
+ */
+declare const OrbitalIdSchema: z.ZodEffects<z.ZodString, OrbitalId, string>;
+declare const EntityIdSchema: z.ZodEffects<z.ZodString, EntityId, string>;
+declare const TraitIdSchema: z.ZodEffects<z.ZodString, TraitId, string>;
+declare const EventIdSchema: z.ZodEffects<z.ZodString, EventId, string>;
+declare const PageIdSchema: z.ZodEffects<z.ZodString, PageId, string>;
+declare const ServiceIdSchema: z.ZodEffects<z.ZodString, ServiceId, string>;
+declare const ThemeIdSchema: z.ZodEffects<z.ZodString, ThemeId, string>;
+declare const PaletteEntryIdSchema: z.ZodEffects<z.ZodString, PaletteEntryId, string>;
+declare const LedgerKindSchema: z.ZodEnum<["orbital", "entity", "trait", "event", "page", "service", "theme"]>;
+declare const LedgerEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<["orbital", "entity", "trait", "event", "page", "service", "theme"]>;
+    bakedName: z.ZodString;
+    curName: z.ZodString;
+    renames: z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+        at: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        at: string;
+        from: string;
+        to: string;
+    }, {
+        at: string;
+        from: string;
+        to: string;
+    }>, "many">;
+    owner: z.ZodEnum<["std", "io", "workspace"]>;
+    parent: z.ZodOptional<z.ZodEffects<z.ZodString, TraitId, string>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    kind: "orbital" | "entity" | "trait" | "event" | "page" | "service" | "theme";
+    bakedName: string;
+    curName: string;
+    renames: {
+        at: string;
+        from: string;
+        to: string;
+    }[];
+    owner: "std" | "io" | "workspace";
+    parent?: TraitId | undefined;
+}, {
+    id: string;
+    kind: "orbital" | "entity" | "trait" | "event" | "page" | "service" | "theme";
+    bakedName: string;
+    curName: string;
+    renames: {
+        at: string;
+        from: string;
+        to: string;
+    }[];
+    owner: "std" | "io" | "workspace";
+    parent?: string | undefined;
+}>;
+declare const IdentityLedgerSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    entries: z.ZodRecord<z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<["orbital", "entity", "trait", "event", "page", "service", "theme"]>;
+        bakedName: z.ZodString;
+        curName: z.ZodString;
+        renames: z.ZodArray<z.ZodObject<{
+            from: z.ZodString;
+            to: z.ZodString;
+            at: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            at: string;
+            from: string;
+            to: string;
+        }, {
+            at: string;
+            from: string;
+            to: string;
+        }>, "many">;
+        owner: z.ZodEnum<["std", "io", "workspace"]>;
+        parent: z.ZodOptional<z.ZodEffects<z.ZodString, TraitId, string>>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        kind: "orbital" | "entity" | "trait" | "event" | "page" | "service" | "theme";
+        bakedName: string;
+        curName: string;
+        renames: {
+            at: string;
+            from: string;
+            to: string;
+        }[];
+        owner: "std" | "io" | "workspace";
+        parent?: TraitId | undefined;
+    }, {
+        id: string;
+        kind: "orbital" | "entity" | "trait" | "event" | "page" | "service" | "theme";
+        bakedName: string;
+        curName: string;
+        renames: {
+            at: string;
+            from: string;
+            to: string;
+        }[];
+        owner: "std" | "io" | "workspace";
+        parent?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    entries: Record<string, {
+        id: string;
+        kind: "orbital" | "entity" | "trait" | "event" | "page" | "service" | "theme";
+        bakedName: string;
+        curName: string;
+        renames: {
+            at: string;
+            from: string;
+            to: string;
+        }[];
+        owner: "std" | "io" | "workspace";
+        parent?: TraitId | undefined;
+    }>;
+    schemaVersion: 1;
+}, {
+    entries: Record<string, {
+        id: string;
+        kind: "orbital" | "entity" | "trait" | "event" | "page" | "service" | "theme";
+        bakedName: string;
+        curName: string;
+        renames: {
+            at: string;
+            from: string;
+            to: string;
+        }[];
+        owner: "std" | "io" | "workspace";
+        parent?: string | undefined;
+    }>;
+    schemaVersion: 1;
+}>;
+
+/**
+ * Field Types for Orbital Units
+ *
+ * Extracted from schema/data-entities.ts for the orbitals module.
+ * These types define the field structure within orbital entities.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Supported field types for entity fields.
+ *
+ * @example
+ * { name: 'status', type: 'enum', values: ['draft', 'published'] }
+ * { name: 'authorId', type: 'relation', relation: { entity: 'User', cardinality: 'one' } }
+ */
+type FieldType = 'string' | 'number' | 'boolean' | 'date' | 'timestamp' | 'datetime' | 'email' | 'url' | 'phone' | 'uuid' | 'image' | 'array' | 'object' | 'enum' | 'relation' | 'trait' | 'slot' | 'pattern';
+/** Every `FieldType`, as a runtime array. Downstream imports this instead of
+ *  re-listing the union — five copies had already drifted apart. */
+declare const FIELD_TYPES: readonly ["string", "number", "boolean", "date", "timestamp", "datetime", "email", "url", "phone", "uuid", "image", "array", "object", "enum", "relation", "trait", "slot", "pattern"];
+/** The semantic string domains — constrained strings, validatable by value. */
+declare const SEMANTIC_STRING_TYPES: readonly ["email", "url", "phone", "uuid", "image"];
+type SemanticStringType = (typeof SEMANTIC_STRING_TYPES)[number];
+/** Is this a semantic string domain (as opposed to a bare `string`)? */
+declare function isSemanticStringType(type: FieldType): type is SemanticStringType;
+declare const FieldTypeSchema: z.ZodEnum<["string", "number", "boolean", "date", "timestamp", "datetime", "email", "url", "phone", "uuid", "image", "array", "object", "enum", "relation", "trait", "slot", "pattern"]>;
+/**
+ * Cardinality for relation fields.
+ * Matches Rust compiler's Cardinality enum.
+ */
+type RelationCardinality = 'one' | 'many' | 'one-to-many' | 'many-to-one' | 'many-to-many';
+/**
+ * Configuration for relation fields (foreign keys).
+ * Matches Rust compiler's RelationDefinition format.
+ */
+type RelationConfig = {
+    /** Target entity name (e.g., 'User', 'Task') - matches Rust's `entity` field */
+    entity: string;
+    /** V4 dual-carry id sibling of `entity` — optional until the Phase-7 flip. */
+    entityId?: EntityId;
+    /** Field on target entity (defaults to 'id') */
+    field?: string;
+    /**
+     * Cardinality: one, many, one-to-many, many-to-one, many-to-many
+     * Matches Rust compiler's cardinality format
+     */
+    cardinality?: RelationCardinality;
+    /** Delete behavior */
+    onDelete?: 'cascade' | 'nullify' | 'restrict';
+    /**
+     * Foreign key field name (for legacy compatibility).
+     * @deprecated Use field instead
+     */
+    foreignKey?: string;
+    /**
+     * Target entity name (for legacy compatibility).
+     * @deprecated Use entity instead
+     */
+    target?: string;
+    /**
+     * Cardinality type alias (for legacy compatibility).
+     * @deprecated Use cardinality instead
+     */
+    type?: RelationCardinality;
+};
+declare const RelationConfigSchema: z.ZodEffects<z.ZodObject<{
+    entity: z.ZodString;
+    entityId: z.ZodOptional<z.ZodEffects<z.ZodString, EntityId, string>>;
+    field: z.ZodOptional<z.ZodString>;
+    cardinality: z.ZodOptional<z.ZodEnum<["one", "many", "one-to-many", "many-to-one", "many-to-many"]>>;
+    onDelete: z.ZodOptional<z.ZodEnum<["cascade", "nullify", "restrict"]>>;
+    foreignKey: z.ZodOptional<z.ZodString>;
+    target: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodEnum<["one", "many", "one-to-many", "many-to-one", "many-to-many"]>>;
+}, "strip", z.ZodTypeAny, {
+    entity: string;
+    type?: "many" | "one" | "one-to-many" | "many-to-one" | "many-to-many" | undefined;
+    entityId?: EntityId | undefined;
+    field?: string | undefined;
+    cardinality?: "many" | "one" | "one-to-many" | "many-to-one" | "many-to-many" | undefined;
+    onDelete?: "cascade" | "nullify" | "restrict" | undefined;
+    foreignKey?: string | undefined;
+    target?: string | undefined;
+}, {
+    entity: string;
+    type?: "many" | "one" | "one-to-many" | "many-to-one" | "many-to-many" | undefined;
+    entityId?: string | undefined;
+    field?: string | undefined;
+    cardinality?: "many" | "one" | "one-to-many" | "many-to-one" | "many-to-many" | undefined;
+    onDelete?: "cascade" | "nullify" | "restrict" | undefined;
+    foreignKey?: string | undefined;
+    target?: string | undefined;
+}>, RelationConfig, {
+    entity: string;
+    type?: "many" | "one" | "one-to-many" | "many-to-one" | "many-to-many" | undefined;
+    entityId?: string | undefined;
+    field?: string | undefined;
+    cardinality?: "many" | "one" | "one-to-many" | "many-to-one" | "many-to-many" | undefined;
+    onDelete?: "cascade" | "nullify" | "restrict" | undefined;
+    foreignKey?: string | undefined;
+    target?: string | undefined;
+}>;
+declare function isEmailValue(value: string): boolean;
+declare function isUrlValue(value: string): boolean;
+declare function isPhoneValue(value: string): boolean;
+declare function isUuidValue(value: string): boolean;
+/** Does `value` satisfy the declared semantic domain? `image` is a URL. */
+declare function isSemanticStringValue(type: SemanticStringType, value: string): boolean;
+/**
+ * Field-type tags that don't carry a type-dependent payload. The base
+ * `EntityField` shape applies as-is.
+ */
+type ScalarFieldType = 'string' | 'number' | 'boolean' | 'date' | 'timestamp' | 'datetime' | 'email' | 'url' | 'phone' | 'uuid' | 'image' | 'trait' | 'slot' | 'pattern';
+/** Fields shared across every variant. */
+type EntityFieldBase = {
+    /**
+     * Field name (camelCase). Optional for nested item/property descriptors
+     * where the name is implied by the parent (`items`, `properties[k]`).
+     * Mirrors Rust's `FieldDefinition.name: Option<String>`.
+     */
+    name?: string;
+    /** Whether the field is required */
+    required?: boolean;
+    /** Default value — parsed from `.orb`, always JSON-shaped. */
+    default?: JsonValue;
+    /** Minimum value (for number) or length (for string) */
+    min?: number;
+    /** Maximum value or length */
+    max?: number;
+    /** Object property schemas keyed by property name (for object type).
+     *  Mirrors Rust's `FieldDefinition.properties: Option<HashMap<String,
+     *  FieldDefinition>>`. Populated by the lolo lowerer when a field /
+     *  config slot's type expression resolves to a struct shape
+     *  (`TypeExpr::Object`), including named-type aliases like `[MetricSpec]`. */
+    properties?: Record<string, EntityField>;
+    /** Runtime-managed widget state (authored `@intrinsic` in `.lolo`). Exempt
+     *  from the explicit-binding rule and never a domain-data bind target. */
+    intrinsic?: boolean;
+    /** Human/semantic description (authored `@description "..."` in `.lolo`).
+     *  Authoring/build-time metadata — factory-signature catalog, embeddings,
+     *  curation field-matching; the runtime ignores it. */
+    description?: string;
+    /** User-vocabulary synonyms (authored `@synonyms "..."` in `.lolo`).
+     *  Free text feeding catalog search / curation field-matching. */
+    synonyms?: string;
+};
+/**
+ * Scalar / structural fields — no type-dependent payload required.
+ * `values?` is permitted as an OPTIONAL UI/validation hint (e.g. lolo's
+ * `'a' | 'b' | 'c'` string-union sugar lowers to `type: 'string', values:
+ * [...]`). Only `EnumEntityField` MANDATES values.
+ */
+type ScalarEntityField = EntityFieldBase & {
+    type: ScalarFieldType;
+    /** Optional vocabulary hint for scalar fields (e.g. string unions
+     *  authored as `'a'|'b'|'c'` in lolo). Not required at this variant. */
+    values?: string[];
+};
+/** `type: 'enum'` REQUIRES the closed vocabulary in `values`. */
+type EnumEntityField = EntityFieldBase & {
+    type: 'enum';
+    /** Closed string vocabulary the field accepts. */
+    values: string[];
+};
+/** `type: 'relation'` REQUIRES the relation target binding. */
+type RelationEntityField = EntityFieldBase & {
+    type: 'relation';
+    /** Relation target binding (entity + cardinality). */
+    relation: RelationConfig;
+};
+/** `type: 'array'` — element schema in `items` strongly preferred but
+ *  optional for legacy compatibility with codegen-emitted scalar-array
+ *  fields (e.g. `{type: 'array', default: []}`). The lolo lowerer + Rust
+ *  validator catch typed-element-required cases downstream. */
+type ArrayEntityField = EntityFieldBase & {
+    type: 'array';
+    /** Element schema for the array. */
+    items?: EntityField;
+};
+/**
+ * `type: 'object'` — a fixed-key struct (fields in `properties`) OR a
+ * dynamic-key map (`Map K V` in `.lolo`; the uniform value schema lives in
+ * `items`, mirroring an array's element schema). A distinct variant so `items`
+ * is statically allowed only on object/array fields, never on scalars.
+ */
+type ObjectEntityField = EntityFieldBase & {
+    type: 'object';
+    /** Uniform value schema for a dynamic-key map (`Map K V`). */
+    items?: EntityField;
+};
+/**
+ * Entity field definition — discriminated union by `type`. Each variant
+ * statically enforces its dependent payload (`values` for enum,
+ * `relation` for relation, `items` for array) so TS / Zod / JSON Schema
+ * consumers all agree on the dependency, not just the Rust validator.
+ *
+ * @example
+ * { name: 'status', type: 'enum', values: ['draft', 'published'] }
+ * { name: 'authorId', type: 'relation', relation: { entity: 'User', cardinality: 'one' } }
+ * { name: 'tags', type: 'array', items: { type: 'string' } }
+ */
+type EntityField = ScalarEntityField | EnumEntityField | RelationEntityField | ArrayEntityField | ObjectEntityField;
+/**
+ * Zod schema for `EntityField`. Preprocess normalizes:
+ *   - legacy `type` aliases (text → string, int → number, etc.)
+ *   - legacy `enum: string[]` alias → `values: string[]`
+ *
+ * Branches on `type` so TS narrows the parsed output to the matching
+ * discriminated-union variant.
+ */
+declare const EntityFieldSchema: z.ZodType<EntityField, z.ZodTypeDef, unknown>;
+type EntityFieldInput = z.input<typeof EntityFieldSchema>;
+/** Alias for EntityField - preferred name */
+type Field = EntityField;
+/** Alias for EntityFieldSchema - preferred name */
+declare const FieldSchema: z.ZodType<EntityField, z.ZodTypeDef, unknown>;
+
+/**
+ * Asset Types for Semantic Asset References
+ *
+ * Defines types for abstracting asset paths into semantic references.
+ * Assets are resolved from SemanticAssetRef to actual paths at compile time.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Entity roles in game contexts
+ */
+declare const ENTITY_ROLES: readonly ["player", "enemy", "npc", "item", "tile", "projectile", "effect", "ui", "decoration", "vehicle"];
+type EntityRole = (typeof ENTITY_ROLES)[number];
+declare const EntityRoleSchema: z.ZodEnum<["player", "enemy", "npc", "item", "tile", "projectile", "effect", "ui", "decoration", "vehicle"]>;
+/**
+ * Visual art styles for games
+ */
+declare const VISUAL_STYLES: readonly ["pixel", "vector", "hd", "1-bit", "isometric"];
+type VisualStyle = (typeof VISUAL_STYLES)[number];
+declare const VisualStyleSchema: z.ZodEnum<["pixel", "vector", "hd", "1-bit", "isometric"]>;
+/**
+ * Whether the asset is a 2D sprite/image or a 3D model. Set by the consuming
+ * canvas: the same entity role is a 2D sprite-sheet on a tile board and a 3D
+ * rigged model on a 3D board.
+ */
+declare const ASSET_DIMENSIONS: readonly ["2d", "3d"];
+type AssetDimension = (typeof ASSET_DIMENSIONS)[number];
+declare const AssetDimensionSchema: z.ZodEnum<["2d", "3d"]>;
+/**
+ * Rendering aspect ratio of an asset: square (tiles/sprites/portraits/icons),
+ * 16:9 (scene backdrops), 5:7 (cards), 8:1 (effect frame strips).
+ */
+declare const ASSET_ASPECTS: readonly ["1:1", "16:9", "5:7", "8:1"];
+type AssetAspect = (typeof ASSET_ASPECTS)[number];
+declare const AssetAspectSchema: z.ZodEnum<["1:1", "16:9", "5:7", "8:1"]>;
+/**
+ * Animation names matching a sprite sheet's row layout. Canonical home for
+ * this vocabulary — `@almadar/ui`'s `spriteAnimationTypes.ts` re-exports it
+ * rather than redeclaring, so board `.lolo` config and the render library
+ * agree on one enum.
+ */
+declare const ANIMATION_NAMES: readonly ["idle", "walk", "attack", "hit", "death"];
+type AnimationName = (typeof ANIMATION_NAMES)[number];
+declare const AnimationNameSchema: z.ZodEnum<["idle", "walk", "attack", "hit", "death"]>;
+/** Sheet file directions (physical PNG files a sprite sheet ships as). */
+declare const SPRITE_DIRECTIONS: readonly ["se", "sw"];
+type SpriteDirection = (typeof SPRITE_DIRECTIONS)[number];
+declare const SpriteDirectionSchema: z.ZodEnum<["se", "sw"]>;
+/**
+ * Definition for a single named animation within a sprite sheet: which row
+ * it occupies, how many frames it has, and its playback rate. This is the
+ * shape actually consumed by `@almadar/ui`'s sprite-sheet renderer
+ * (`spriteAnimation.ts`'s `frameRect`/`getCurrentFrameFromDef`) — moved here
+ * verbatim rather than reconciled with a differently-shaped guess, since
+ * `@almadar/ui`'s version is the one with real production consumers.
+ */
+interface AnimationDef {
+    /** Row index in the sprite sheet (0-based; each animation occupies one row). */
+    row: number;
+    /** Number of frames in this animation. */
+    frames: number;
+    /** Frames per second. */
+    frameRate: number;
+    /** Whether the animation loops. */
+    loop: boolean;
+}
+declare const AnimationDefSchema: z.ZodObject<{
+    row: z.ZodNumber;
+    frames: z.ZodNumber;
+    frameRate: z.ZodNumber;
+    loop: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    row: number;
+    frames: number;
+    frameRate: number;
+    loop: boolean;
+}, {
+    row: number;
+    frames: number;
+    frameRate: number;
+    loop: boolean;
+}>;
+/**
+ * Parsed sprite-sheet atlas JSON — the contract a `spriteSheet`-role `Asset.url`
+ * resolves to when fetched (see `Asset.url` usage in `@almadar/ui`'s
+ * `useUnitSpriteAtlas`). A unit's `sprite?: Asset` stays the static single-pose
+ * image; `spriteSheet?: Asset` is a SEPARATE reference whose URL points at a
+ * `SpriteSheetAtlas`-shaped JSON manifest (e.g. `.../guardian-sprite-sheet.json`),
+ * not a PNG. Frame-cutting geometry lives here, not inlined onto `Asset` — an
+ * `Asset` traveling through `render-ui` every tick stays small.
+ */
+interface SpriteSheetAtlas {
+    /** Unit archetype key. */
+    unit?: string;
+    /** Visual type key. */
+    type?: string;
+    /** Width of a single frame in pixels. */
+    frameWidth: number;
+    /** Height of a single frame in pixels. */
+    frameHeight: number;
+    /** Number of columns (frames per row). */
+    columns: number;
+    /** Number of rows (animations). */
+    rows: number;
+    /** Directions present as physical PNG files. */
+    directions: SpriteDirection[];
+    /** Relative PNG sheet paths per direction. */
+    sheets: Partial<Record<SpriteDirection, string>>;
+    /** Animation row layout keyed by animation name. */
+    animations: Partial<Record<AnimationName, AnimationDef>>;
+}
+declare const SpriteSheetAtlasSchema: z.ZodObject<{
+    unit: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodString>;
+    frameWidth: z.ZodNumber;
+    frameHeight: z.ZodNumber;
+    columns: z.ZodNumber;
+    rows: z.ZodNumber;
+    directions: z.ZodArray<z.ZodEnum<["se", "sw"]>, "many">;
+    sheets: z.ZodRecord<z.ZodEnum<["se", "sw"]>, z.ZodString>;
+    animations: z.ZodRecord<z.ZodEnum<["idle", "walk", "attack", "hit", "death"]>, z.ZodObject<{
+        row: z.ZodNumber;
+        frames: z.ZodNumber;
+        frameRate: z.ZodNumber;
+        loop: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        row: number;
+        frames: number;
+        frameRate: number;
+        loop: boolean;
+    }, {
+        row: number;
+        frames: number;
+        frameRate: number;
+        loop: boolean;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    frameWidth: number;
+    frameHeight: number;
+    columns: number;
+    rows: number;
+    directions: ("se" | "sw")[];
+    sheets: Partial<Record<"se" | "sw", string>>;
+    animations: Partial<Record<"idle" | "walk" | "attack" | "hit" | "death", {
+        row: number;
+        frames: number;
+        frameRate: number;
+        loop: boolean;
+    }>>;
+    type?: string | undefined;
+    unit?: string | undefined;
+}, {
+    frameWidth: number;
+    frameHeight: number;
+    columns: number;
+    rows: number;
+    directions: ("se" | "sw")[];
+    sheets: Partial<Record<"se" | "sw", string>>;
+    animations: Partial<Record<"idle" | "walk" | "attack" | "hit" | "death", {
+        row: number;
+        frames: number;
+        frameRate: number;
+        loop: boolean;
+    }>>;
+    type?: string | undefined;
+    unit?: string | undefined;
+}>;
+/**
+ * One named sub-rectangle inside a packed sheet. Mirrors the ShoeBox /
+ * TexturePacker `<SubTexture>` element every Kenney `Spritesheet/*.xml` ships
+ * (`x`/`y`/`width`/`height` = the rect in the sheet PNG; `frameX`/`frameY`/
+ * `frameWidth`/`frameHeight` = the trim/pad offsets for sprites packed with
+ * transparent edges removed — optional, present only on trimmed atlases).
+ */
+interface SubTexture {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    frameX?: number;
+    frameY?: number;
+    frameWidth?: number;
+    frameHeight?: number;
+}
+declare const SubTextureSchema: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+    frameX: z.ZodOptional<z.ZodNumber>;
+    frameY: z.ZodOptional<z.ZodNumber>;
+    frameWidth: z.ZodOptional<z.ZodNumber>;
+    frameHeight: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    frameWidth?: number | undefined;
+    frameHeight?: number | undefined;
+    frameX?: number | undefined;
+    frameY?: number | undefined;
+}, {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    frameWidth?: number | undefined;
+    frameHeight?: number | undefined;
+    frameX?: number | undefined;
+    frameY?: number | undefined;
+}>;
+/**
+ * A packed sheet + its named sub-rectangles — the canonical parse target for a
+ * Kenney `Spritesheet/*.xml` atlas. A STATIC tile/prop/UI Asset references one
+ * of these: `{ url: <sheet.png>, atlas: <this.json>, sprite: "grass.png" }` →
+ * the renderer fetches the sheet + atlas ONCE and blits the named sub-rect,
+ * instead of loading N individual PNGs. (Animated actors use `SpriteSheetAtlas`
+ * instead; a uniform-grid tile page uses `Tilesheet`.)
+ */
+interface TextureAtlas {
+    /** Relative path to the sheet PNG the sub-rects index into (the atlas's own `imagePath`). */
+    imagePath: string;
+    /** Sub-rectangles keyed by their atlas name (e.g. `"grass.png"`). */
+    subTextures: Record<string, SubTexture>;
+}
+declare const TextureAtlasSchema: z.ZodObject<{
+    imagePath: z.ZodString;
+    subTextures: z.ZodRecord<z.ZodString, z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+        frameX: z.ZodOptional<z.ZodNumber>;
+        frameY: z.ZodOptional<z.ZodNumber>;
+        frameWidth: z.ZodOptional<z.ZodNumber>;
+        frameHeight: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        frameWidth?: number | undefined;
+        frameHeight?: number | undefined;
+        frameX?: number | undefined;
+        frameY?: number | undefined;
+    }, {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        frameWidth?: number | undefined;
+        frameHeight?: number | undefined;
+        frameX?: number | undefined;
+        frameY?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    imagePath: string;
+    subTextures: Record<string, {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        frameWidth?: number | undefined;
+        frameHeight?: number | undefined;
+        frameX?: number | undefined;
+        frameY?: number | undefined;
+    }>;
+}, {
+    imagePath: string;
+    subTextures: Record<string, {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        frameWidth?: number | undefined;
+        frameHeight?: number | undefined;
+        frameX?: number | undefined;
+        frameY?: number | undefined;
+    }>;
+}>;
+/**
+ * A uniform-grid tile page — the shape a Kenney `Tilesheet/` sheet takes (e.g.
+ * Pirate Pack: "each tile is 64×64, no margin"). Tiles are cut by `(col,row)`
+ * index rather than by named rect. `names` is present only when a sibling
+ * `.xml`/`.txt` supplies an index→name list; otherwise a tile is addressed by
+ * its `"col,row"` (or flat index) via `Asset.sprite`.
+ */
+interface Tilesheet {
+    /** Relative path to the tile sheet PNG. */
+    imagePath: string;
+    /** Width of one tile cell in pixels. */
+    tileWidth: number;
+    /** Height of one tile cell in pixels. */
+    tileHeight: number;
+    /** Number of columns in the grid. */
+    columns: number;
+    /** Number of rows in the grid. */
+    rows: number;
+    /** Outer margin before the first tile, in pixels (default 0). */
+    margin?: number;
+    /** Gap between adjacent tiles, in pixels (default 0). */
+    spacing?: number;
+    /** Optional index→name labels when a descriptor supplies them. */
+    names?: string[];
+}
+declare const TilesheetSchema: z.ZodObject<{
+    imagePath: z.ZodString;
+    tileWidth: z.ZodNumber;
+    tileHeight: z.ZodNumber;
+    columns: z.ZodNumber;
+    rows: z.ZodNumber;
+    margin: z.ZodOptional<z.ZodNumber>;
+    spacing: z.ZodOptional<z.ZodNumber>;
+    names: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    columns: number;
+    rows: number;
+    imagePath: string;
+    tileWidth: number;
+    tileHeight: number;
+    margin?: number | undefined;
+    spacing?: number | undefined;
+    names?: string[] | undefined;
+}, {
+    columns: number;
+    rows: number;
+    imagePath: string;
+    tileWidth: number;
+    tileHeight: number;
+    margin?: number | undefined;
+    spacing?: number | undefined;
+    names?: string[] | undefined;
+}>;
+/**
+ * Semantic reference to an asset (not a hardcoded path).
+ * Resolved to actual paths at compile time via asset maps.
+ */
+type SemanticAssetRef = {
+    /**
+     * Entity role — a free string. Core no longer constrains the vocabulary to
+     * `EntityRole` (that enum stays an exported shared reference for the asset
+     * tool + renderer); genre boards may use their own roles (`boss`, `tower`, …).
+     */
+    role: string;
+    /** Sub-category within role (hero, slime, coin, etc.) */
+    category: string;
+    /** Required animations for this entity */
+    animations?: string[];
+    /** Visual style preference */
+    style?: VisualStyle;
+    /** Variant identifier (for multiple versions) */
+    variant?: string;
+    /** 2D sprite vs 3D model — the rendering dimension the consuming canvas needs. */
+    dimension?: AssetDimension;
+    /** Rendering aspect ratio (square sprite/portrait/tile, 16:9 backdrop, 5:7 card, 8:1 fx-strip). */
+    aspect?: AssetAspect;
+};
+declare const SemanticAssetRefSchema: z.ZodObject<{
+    role: z.ZodString;
+    category: z.ZodString;
+    animations: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    style: z.ZodOptional<z.ZodEnum<["pixel", "vector", "hd", "1-bit", "isometric"]>>;
+    variant: z.ZodOptional<z.ZodString>;
+    dimension: z.ZodOptional<z.ZodEnum<["2d", "3d"]>>;
+    aspect: z.ZodOptional<z.ZodEnum<["1:1", "16:9", "5:7", "8:1"]>>;
+}, "strip", z.ZodTypeAny, {
+    role: string;
+    category: string;
+    animations?: string[] | undefined;
+    style?: "pixel" | "vector" | "hd" | "1-bit" | "isometric" | undefined;
+    variant?: string | undefined;
+    dimension?: "2d" | "3d" | undefined;
+    aspect?: "1:1" | "16:9" | "5:7" | "8:1" | undefined;
+}, {
+    role: string;
+    category: string;
+    animations?: string[] | undefined;
+    style?: "pixel" | "vector" | "hd" | "1-bit" | "isometric" | undefined;
+    variant?: string | undefined;
+    dimension?: "2d" | "3d" | undefined;
+    aspect?: "1:1" | "16:9" | "5:7" | "8:1" | undefined;
+}>;
+/**
+ * The single asset type: a `SemanticAssetRef` (role/dimension/animations/aspect/style)
+ * WITH its resolved URL folded in. Used everywhere an asset is referenced — a lolo
+ * board `assetManifest` (`Map string Asset`), every `@almadar/ui` game prop, the
+ * asset-workflow's resolved/pool assets, and the inspector picker. Replaces the bare
+ * `AssetUrl`-string asset field so the render metadata travels WITH the asset (no
+ * pixel-dimension or filename heuristics needed to know sheet-vs-frame / 2d-vs-3d).
+ */
+interface Asset extends SemanticAssetRef {
+    /** The resolved asset URL. When `atlas`/`sprite` are set this is the SHEET png; otherwise a standalone image. */
+    url: AssetUrl;
+    /**
+     * Optional atlas JSON (a `TextureAtlas` or `Tilesheet`) that slices `url`.
+     * When present with `sprite`, the renderer fetches sheet + atlas once and
+     * blits one sub-rect instead of loading a standalone PNG. Absent → `url` is
+     * a plain whole-image asset (the existing, non-atlas path).
+     */
+    atlas?: AssetUrl;
+    /**
+     * The sub-texture selector within `atlas`: a `SubTexture` name for a
+     * `TextureAtlas` (e.g. `"grass.png"`), or a `"col,row"`/flat index for a
+     * `Tilesheet`. Only meaningful alongside `atlas`.
+     */
+    sprite?: string;
+    /** Optional display name (inspector picker). */
+    name?: string;
+    /** Optional thumbnail URL (inspector picker grid). */
+    thumbnailUrl?: string;
+}
+declare const AssetSchema: z.ZodObject<{
+    role: z.ZodString;
+    category: z.ZodString;
+    animations: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    style: z.ZodOptional<z.ZodEnum<["pixel", "vector", "hd", "1-bit", "isometric"]>>;
+    variant: z.ZodOptional<z.ZodString>;
+    dimension: z.ZodOptional<z.ZodEnum<["2d", "3d"]>>;
+    aspect: z.ZodOptional<z.ZodEnum<["1:1", "16:9", "5:7", "8:1"]>>;
+} & {
+    url: z.ZodString;
+    atlas: z.ZodOptional<z.ZodString>;
+    sprite: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    thumbnailUrl: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+    role: string;
+    category: string;
+    name?: string | undefined;
+    animations?: string[] | undefined;
+    style?: "pixel" | "vector" | "hd" | "1-bit" | "isometric" | undefined;
+    variant?: string | undefined;
+    dimension?: "2d" | "3d" | undefined;
+    aspect?: "1:1" | "16:9" | "5:7" | "8:1" | undefined;
+    atlas?: string | undefined;
+    sprite?: string | undefined;
+    thumbnailUrl?: string | undefined;
+}, {
+    url: string;
+    role: string;
+    category: string;
+    name?: string | undefined;
+    animations?: string[] | undefined;
+    style?: "pixel" | "vector" | "hd" | "1-bit" | "isometric" | undefined;
+    variant?: string | undefined;
+    dimension?: "2d" | "3d" | undefined;
+    aspect?: "1:1" | "16:9" | "5:7" | "8:1" | undefined;
+    atlas?: string | undefined;
+    sprite?: string | undefined;
+    thumbnailUrl?: string | undefined;
+}>;
+/**
+ * Single browsable asset in the inspector picker catalog.
+ * Backs the asset/icon pickers — a flat list the inspector renders for
+ * the user to choose from when a config field's type is `'asset'`.
+ */
+interface AssetCatalogEntry {
+    /** Resolvable URL to the asset. */
+    url: string;
+    /** Display name for the asset. */
+    name: string;
+    /** Grouping category within the catalog. */
+    category: string;
+    /** Asset kind the picker dispatches on. */
+    kind: 'image' | 'spritesheet' | 'audio' | 'scene' | 'portrait' | 'model' | 'other';
+    /** Optional thumbnail URL for grid previews. */
+    thumbnailUrl?: string;
+    /** 2D sprite vs 3D model — the asset's actual rendering dimension. */
+    dimension?: AssetDimension;
+    /** The asset's actual rendering aspect ratio. */
+    aspect?: AssetAspect;
+}
+declare const AssetCatalogEntrySchema: z.ZodObject<{
+    url: z.ZodString;
+    name: z.ZodString;
+    category: z.ZodString;
+    kind: z.ZodEnum<["image", "spritesheet", "audio", "scene", "portrait", "model", "other"]>;
+    thumbnailUrl: z.ZodOptional<z.ZodString>;
+    dimension: z.ZodOptional<z.ZodEnum<["2d", "3d"]>>;
+    aspect: z.ZodOptional<z.ZodEnum<["1:1", "16:9", "5:7", "8:1"]>>;
+}, "strip", z.ZodTypeAny, {
+    kind: "image" | "spritesheet" | "audio" | "scene" | "portrait" | "model" | "other";
+    url: string;
+    name: string;
+    category: string;
+    dimension?: "2d" | "3d" | undefined;
+    aspect?: "1:1" | "16:9" | "5:7" | "8:1" | undefined;
+    thumbnailUrl?: string | undefined;
+}, {
+    kind: "image" | "spritesheet" | "audio" | "scene" | "portrait" | "model" | "other";
+    url: string;
+    name: string;
+    category: string;
+    dimension?: "2d" | "3d" | undefined;
+    aspect?: "1:1" | "16:9" | "5:7" | "8:1" | undefined;
+    thumbnailUrl?: string | undefined;
+}>;
+/**
+ * Flat list of browsable assets surfaced by the inspector pickers.
+ */
+type AssetCatalog = AssetCatalogEntry[];
+declare const AssetCatalogSchema: z.ZodArray<z.ZodObject<{
+    url: z.ZodString;
+    name: z.ZodString;
+    category: z.ZodString;
+    kind: z.ZodEnum<["image", "spritesheet", "audio", "scene", "portrait", "model", "other"]>;
+    thumbnailUrl: z.ZodOptional<z.ZodString>;
+    dimension: z.ZodOptional<z.ZodEnum<["2d", "3d"]>>;
+    aspect: z.ZodOptional<z.ZodEnum<["1:1", "16:9", "5:7", "8:1"]>>;
+}, "strip", z.ZodTypeAny, {
+    kind: "image" | "spritesheet" | "audio" | "scene" | "portrait" | "model" | "other";
+    url: string;
+    name: string;
+    category: string;
+    dimension?: "2d" | "3d" | undefined;
+    aspect?: "1:1" | "16:9" | "5:7" | "8:1" | undefined;
+    thumbnailUrl?: string | undefined;
+}, {
+    kind: "image" | "spritesheet" | "audio" | "scene" | "portrait" | "model" | "other";
+    url: string;
+    name: string;
+    category: string;
+    dimension?: "2d" | "3d" | undefined;
+    aspect?: "1:1" | "16:9" | "5:7" | "8:1" | undefined;
+    thumbnailUrl?: string | undefined;
+}>, "many">;
+/**
+ * Asset-reference URL marker. A plain alias over `string` — the value is a
+ * resolvable asset URL — but the named type lets the pattern-sync tool
+ * (`tools/almadar-pattern-sync/parser.ts`) detect a component prop as an asset
+ * field (tagged `asset`) the same way `EventKey`/`LucideIcon` are detected by
+ * type identity. Components annotate image/url props as `AssetUrl` (`src`,
+ * `backgroundImage`, `avatar`, …); the generator emits a `string` config knob
+ * declared as the `asset` config type, which the property inspector dispatches
+ * an AssetPicker on. Not branded — asset urls originate from user data, so cast
+ * friction would buy nothing; the value is the marker the tool finds.
+ */
+type AssetUrl = string;
+/**
+ * A neutral position in scene space: 2D (`x`,`y`) or optionally 3D (`x`,`y`,`z`).
+ * The single coordinate type shared by every drawable descriptor and camera pose
+ * across the 2D and 3D canvas hosts, so a scene composes from the same `{x,y,z?}`
+ * regardless of projection or painter. Logical, not pixel — the host's projector
+ * maps a `ScenePos` to screen space.
+ */
+interface ScenePos {
+    x: number;
+    y: number;
+    z?: number;
+}
+declare const ScenePosSchema: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    z: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    x: number;
+    y: number;
+    z?: number | undefined;
+}, {
+    x: number;
+    y: number;
+    z?: number | undefined;
+}>;
+/**
+ * Camera behaviors, unifying the former per-host vocab (2D `camera` string +
+ * 3D `cameraMode`). `isometric`/`top-down` are fixed framings; `follow`/`chase`
+ * track a target; `perspective` is the 3D dramatic framing.
+ */
+declare const CAMERA_MODES: readonly ["isometric", "perspective", "top-down", "follow", "chase"];
+type CameraMode = (typeof CAMERA_MODES)[number];
+declare const CameraModeSchema: z.ZodEnum<["isometric", "perspective", "top-down", "follow", "chase"]>;
+/**
+ * A neutral camera pose shared by the 2D and 3D canvas hosts, so `type: canvas`
+ * carries one camera object regardless of painter. `pos`/`target` are `ScenePos`
+ * (logical scene space, not pixels); `zoom` scales the view (the former `scale`);
+ * `fov` is the 3D field of view; `mode` selects the framing/tracking behavior.
+ * Every field is optional — an omitted camera means the host's default framing.
+ */
+interface Camera {
+    pos?: ScenePos;
+    target?: ScenePos;
+    zoom?: number;
+    fov?: number;
+    mode?: CameraMode;
+}
+declare const CameraSchema: z.ZodObject<{
+    pos: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        z: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        x: number;
+        y: number;
+        z?: number | undefined;
+    }, {
+        x: number;
+        y: number;
+        z?: number | undefined;
+    }>>;
+    target: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        z: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        x: number;
+        y: number;
+        z?: number | undefined;
+    }, {
+        x: number;
+        y: number;
+        z?: number | undefined;
+    }>>;
+    zoom: z.ZodOptional<z.ZodNumber>;
+    fov: z.ZodOptional<z.ZodNumber>;
+    mode: z.ZodOptional<z.ZodEnum<["isometric", "perspective", "top-down", "follow", "chase"]>>;
+}, "strip", z.ZodTypeAny, {
+    target?: {
+        x: number;
+        y: number;
+        z?: number | undefined;
+    } | undefined;
+    pos?: {
+        x: number;
+        y: number;
+        z?: number | undefined;
+    } | undefined;
+    zoom?: number | undefined;
+    fov?: number | undefined;
+    mode?: "isometric" | "perspective" | "top-down" | "follow" | "chase" | undefined;
+}, {
+    target?: {
+        x: number;
+        y: number;
+        z?: number | undefined;
+    } | undefined;
+    pos?: {
+        x: number;
+        y: number;
+        z?: number | undefined;
+    } | undefined;
+    zoom?: number | undefined;
+    fov?: number | undefined;
+    mode?: "isometric" | "perspective" | "top-down" | "follow" | "chase" | undefined;
+}>;
+type SemanticAssetRefInput = z.input<typeof SemanticAssetRefSchema>;
+type AnimationDefInput = z.input<typeof AnimationDefSchema>;
+type AssetCatalogEntryInput = z.input<typeof AssetCatalogEntrySchema>;
+type SpriteSheetAtlasInput = z.input<typeof SpriteSheetAtlasSchema>;
+/**
+ * Creates a semantic asset key from role and category.
+ *
+ * Generates a unique asset identifier by combining role and category
+ * with a colon separator. Used for asset management and lookup.
+ *
+ * @param {EntityRole} role - Entity role (e.g., 'player', 'enemy')
+ * @param {string} category - Asset category (e.g., 'sprite', 'animation')
+ * @returns {string} Asset key in format 'role:category'
+ *
+ * @example
+ * createAssetKey('player', 'sprite'); // returns 'player:sprite'
+ * createAssetKey('enemy', 'animation'); // returns 'enemy:animation'
+ */
+declare function createAssetKey(role: EntityRole, category: string): string;
+/**
+ * Parses an asset key into role and category components.
+ *
+ * Deconstructs an asset key string (format 'role:category') into its
+ * constituent parts. Returns null if the key format is invalid.
+ *
+ * @param {string} key - Asset key in format 'role:category'
+ * @returns {{ role: string; category: string } | null} Parsed components or null
+ *
+ * @example
+ * parseAssetKey('player:sprite'); // returns { role: 'player', category: 'sprite' }
+ * parseAssetKey('enemy:animation'); // returns { role: 'enemy', category: 'animation' }
+ * parseAssetKey('invalid'); // returns null
+ */
+declare function parseAssetKey(key: string): {
+    role: string;
+    category: string;
+} | null;
+/**
+ * Gets common animations for an entity role.
+ *
+ * Returns an array of default animation names appropriate for the
+ * specified entity role. Used for asset configuration and validation.
+ *
+ * @param {EntityRole} role - Entity role
+ * @returns {string[]} Array of default animation names
+ *
+ * @example
+ * getDefaultAnimationsForRole('player'); // returns ['idle', 'run', 'jump', 'fall', 'attack', 'hurt', 'die']
+ * getDefaultAnimationsForRole('enemy'); // returns ['idle', 'walk', 'attack', 'hurt', 'die']
+ */
+declare function getDefaultAnimationsForRole(role: EntityRole): string[];
+/**
+ * Validates that an asset reference has required animations.
+ *
+ * Checks if an asset reference contains all required animations.
+ * Returns an error message if validation fails, or null if valid.
+ *
+ * @param {SemanticAssetRef} assetRef - Asset reference to validate
+ * @param {string[]} requiredAnimations - Required animation names
+ * @returns {string | null} Error message or null if valid
+ *
+ * @example
+ * validateAssetAnimations(assetRef, ['idle', 'run']); // returns null if valid
+ * validateAssetAnimations(assetRef, ['missing-animation']); // returns error message
+ */
+declare function validateAssetAnimations(assetRef: SemanticAssetRef, requiredAnimations: string[]): {
+    valid: boolean;
+    missing: string[];
+};
+
+/**
+ * Entity persistence types.
+ *
+ * - persistent: Stored in database (has collection)
+ * - runtime: Exists only at runtime (not persisted)
+ */
+type EntityPersistence = 'persistent' | 'runtime';
+declare const EntityPersistenceSchema: z.ZodEnum<["persistent", "runtime"]>;
+/**
+ * OrbitalEntity - the nucleus of an Orbital Unit.
+ *
+ * This is a simplified entity definition optimized for orbital composition.
+ * Collection names are derived automatically from persistence type if not provided.
+ */
+type OrbitalEntity = {
+    /** V4 dual-carry id sibling of `name` — optional until the Phase-7 flip. */
+    id?: EntityId;
+    /** Entity name (PascalCase, e.g., "Task", "User") */
+    name: string;
+    /** Entity persistence type (defaults to 'persistent' if not specified) */
+    persistence?: EntityPersistence;
+    /** Whether this entity's state is shared across all bound traits (vs per-trait copy). Orthogonal to persistence. */
+    shared?: boolean;
+    /**
+     * Whether this entity types the ambient `@user` viewer. Orthogonal to both
+     * `persistence` and `shared`: `[persistent: people, identity]` is an
+     * app-owned user directory, `[runtime, identity]` the provider-supplied
+     * current viewer. At most one per composed program.
+     */
+    identity?: boolean;
+    /** Collection name (auto-derived if not provided for persistent entities) */
+    collection?: string;
+    /** Entity fields */
+    fields: EntityField[];
+    /** Pre-authored instances (seed data or static reference data) */
+    instances?: EntityRow[];
+    /** Auto-add createdAt/updatedAt timestamps */
+    timestamps?: boolean;
+    /** Soft delete support */
+    softDelete?: boolean;
+    /** Human-readable description */
+    description?: string;
+    /** Visual prompt for AI generation */
+    visual_prompt?: string;
+    /** Semantic asset reference for visual representation (games) */
+    assetRef?: SemanticAssetRef;
+};
+declare const OrbitalEntitySchema: z.ZodObject<{
+    name: z.ZodString;
+    persistence: z.ZodDefault<z.ZodEnum<["persistent", "runtime"]>>;
+    shared: z.ZodOptional<z.ZodBoolean>;
+    identity: z.ZodOptional<z.ZodBoolean>;
+    collection: z.ZodOptional<z.ZodString>;
+    fields: z.ZodArray<z.ZodType<EntityField, z.ZodTypeDef, unknown>, "many">;
+    instances: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, z.ZodTypeDef, JsonValue>>, "many">>;
+    timestamps: z.ZodOptional<z.ZodBoolean>;
+    softDelete: z.ZodOptional<z.ZodBoolean>;
+    description: z.ZodOptional<z.ZodString>;
+    visual_prompt: z.ZodOptional<z.ZodString>;
+    assetRef: z.ZodOptional<z.ZodObject<{
+        role: z.ZodString;
+        category: z.ZodString;
+        animations: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        style: z.ZodOptional<z.ZodEnum<["pixel", "vector", "hd", "1-bit", "isometric"]>>;
+        variant: z.ZodOptional<z.ZodString>;
+        dimension: z.ZodOptional<z.ZodEnum<["2d", "3d"]>>;
+        aspect: z.ZodOptional<z.ZodEnum<["1:1", "16:9", "5:7", "8:1"]>>;
+    }, "strip", z.ZodTypeAny, {
+        role: string;
+        category: string;
+        animations?: string[] | undefined;
+        style?: "pixel" | "vector" | "hd" | "1-bit" | "isometric" | undefined;
+        variant?: string | undefined;
+        dimension?: "2d" | "3d" | undefined;
+        aspect?: "1:1" | "16:9" | "5:7" | "8:1" | undefined;
+    }, {
+        role: string;
+        category: string;
+        animations?: string[] | undefined;
+        style?: "pixel" | "vector" | "hd" | "1-bit" | "isometric" | undefined;
+        variant?: string | undefined;
+        dimension?: "2d" | "3d" | undefined;
+        aspect?: "1:1" | "16:9" | "5:7" | "8:1" | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    persistence: "persistent" | "runtime";
+    fields: EntityField[];
+    description?: string | undefined;
+    shared?: boolean | undefined;
+    identity?: boolean | undefined;
+    collection?: string | undefined;
+    instances?: Record<string, JsonValue>[] | undefined;
+    timestamps?: boolean | undefined;
+    softDelete?: boolean | undefined;
+    visual_prompt?: string | undefined;
+    assetRef?: {
+        role: string;
+        category: string;
+        animations?: string[] | undefined;
+        style?: "pixel" | "vector" | "hd" | "1-bit" | "isometric" | undefined;
+        variant?: string | undefined;
+        dimension?: "2d" | "3d" | undefined;
+        aspect?: "1:1" | "16:9" | "5:7" | "8:1" | undefined;
+    } | undefined;
+}, {
+    name: string;
+    fields: unknown[];
+    description?: string | undefined;
+    persistence?: "persistent" | "runtime" | undefined;
+    shared?: boolean | undefined;
+    identity?: boolean | undefined;
+    collection?: string | undefined;
+    instances?: Record<string, JsonValue>[] | undefined;
+    timestamps?: boolean | undefined;
+    softDelete?: boolean | undefined;
+    visual_prompt?: string | undefined;
+    assetRef?: {
+        role: string;
+        category: string;
+        animations?: string[] | undefined;
+        style?: "pixel" | "vector" | "hd" | "1-bit" | "isometric" | undefined;
+        variant?: string | undefined;
+        dimension?: "2d" | "3d" | undefined;
+        aspect?: "1:1" | "16:9" | "5:7" | "8:1" | undefined;
+    } | undefined;
+}>;
+type OrbitalEntityInput = z.input<typeof OrbitalEntitySchema>;
+/** Alias for OrbitalEntity - preferred name */
+type Entity = OrbitalEntity;
+/** Alias for OrbitalEntitySchema - preferred name */
+declare const EntitySchema: z.ZodObject<{
+    name: z.ZodString;
+    persistence: z.ZodDefault<z.ZodEnum<["persistent", "runtime"]>>;
+    shared: z.ZodOptional<z.ZodBoolean>;
+    identity: z.ZodOptional<z.ZodBoolean>;
+    collection: z.ZodOptional<z.ZodString>;
+    fields: z.ZodArray<z.ZodType<EntityField, z.ZodTypeDef, unknown>, "many">;
+    instances: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, z.ZodTypeDef, JsonValue>>, "many">>;
+    timestamps: z.ZodOptional<z.ZodBoolean>;
+    softDelete: z.ZodOptional<z.ZodBoolean>;
+    description: z.ZodOptional<z.ZodString>;
+    visual_prompt: z.ZodOptional<z.ZodString>;
+    assetRef: z.ZodOptional<z.ZodObject<{
+        role: z.ZodString;
+        category: z.ZodString;
+        animations: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        style: z.ZodOptional<z.ZodEnum<["pixel", "vector", "hd", "1-bit", "isometric"]>>;
+        variant: z.ZodOptional<z.ZodString>;
+        dimension: z.ZodOptional<z.ZodEnum<["2d", "3d"]>>;
+        aspect: z.ZodOptional<z.ZodEnum<["1:1", "16:9", "5:7", "8:1"]>>;
+    }, "strip", z.ZodTypeAny, {
+        role: string;
+        category: string;
+        animations?: string[] | undefined;
+        style?: "pixel" | "vector" | "hd" | "1-bit" | "isometric" | undefined;
+        variant?: string | undefined;
+        dimension?: "2d" | "3d" | undefined;
+        aspect?: "1:1" | "16:9" | "5:7" | "8:1" | undefined;
+    }, {
+        role: string;
+        category: string;
+        animations?: string[] | undefined;
+        style?: "pixel" | "vector" | "hd" | "1-bit" | "isometric" | undefined;
+        variant?: string | undefined;
+        dimension?: "2d" | "3d" | undefined;
+        aspect?: "1:1" | "16:9" | "5:7" | "8:1" | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    persistence: "persistent" | "runtime";
+    fields: EntityField[];
+    description?: string | undefined;
+    shared?: boolean | undefined;
+    identity?: boolean | undefined;
+    collection?: string | undefined;
+    instances?: Record<string, JsonValue>[] | undefined;
+    timestamps?: boolean | undefined;
+    softDelete?: boolean | undefined;
+    visual_prompt?: string | undefined;
+    assetRef?: {
+        role: string;
+        category: string;
+        animations?: string[] | undefined;
+        style?: "pixel" | "vector" | "hd" | "1-bit" | "isometric" | undefined;
+        variant?: string | undefined;
+        dimension?: "2d" | "3d" | undefined;
+        aspect?: "1:1" | "16:9" | "5:7" | "8:1" | undefined;
+    } | undefined;
+}, {
+    name: string;
+    fields: unknown[];
+    description?: string | undefined;
+    persistence?: "persistent" | "runtime" | undefined;
+    shared?: boolean | undefined;
+    identity?: boolean | undefined;
+    collection?: string | undefined;
+    instances?: Record<string, JsonValue>[] | undefined;
+    timestamps?: boolean | undefined;
+    softDelete?: boolean | undefined;
+    visual_prompt?: string | undefined;
+    assetRef?: {
+        role: string;
+        category: string;
+        animations?: string[] | undefined;
+        style?: "pixel" | "vector" | "hd" | "1-bit" | "isometric" | undefined;
+        variant?: string | undefined;
+        dimension?: "2d" | "3d" | undefined;
+        aspect?: "1:1" | "16:9" | "5:7" | "8:1" | undefined;
+    } | undefined;
+}>;
+/**
+ * Derives the collection name for a persistent entity.
+ *
+ * Generates the database collection name by converting the entity name
+ * to lowercase and adding an 's' suffix (simple pluralization).
+ * Returns undefined for non-persistent (runtime) entities.
+ *
+ * @param {OrbitalEntity} entity - Entity to derive collection name for
+ * @returns {string | undefined} Collection name or undefined for non-persistent entities
+ *
+ * @example
+ * deriveCollection({ name: 'User', persistence: 'persistent' }); // returns 'users'
+ * deriveCollection({ name: 'Task', persistence: 'runtime' }); // returns undefined
+ */
+declare function deriveCollection(entity: OrbitalEntity): string | undefined;
+/**
+ * Checks if an entity is runtime-only (not persisted).
+ *
+ * Type guard to determine if an entity exists only at runtime
+ * and is not stored in the database.
+ *
+ * @param {OrbitalEntity} entity - Entity to check
+ * @returns {boolean} True if entity is runtime-only, false otherwise
+ *
+ * @example
+ * isRuntimeEntity({ persistence: 'runtime' }); // returns true
+ * isRuntimeEntity({ persistence: 'persistent' }); // returns false
+ */
+declare function isRuntimeEntity(entity: OrbitalEntity): boolean;
+/**
+ * Checks whether an entity's persistence mode allows `persistence` /
+ * `collection` overrides at the factory call site.
+ *
+ * Only `persistent` entities (explicit or default) support these overrides.
+ * Runtime entities are fixed; callers must not expose `persistence` or
+ * `collection` params for them.
+ *
+ * @param persistence - The entity persistence mode (undefined = default persistent)
+ * @returns True when overrides are allowed, false otherwise
+ *
+ * @example
+ * persistenceModeAllowsOverrides('persistent'); // returns true
+ * persistenceModeAllowsOverrides('runtime');    // returns false
+ * persistenceModeAllowsOverrides(undefined);    // returns true (default persistent)
+ */
+declare function persistenceModeAllowsOverrides(persistence: EntityPersistence | undefined): boolean;
+/**
+ * A single field value at runtime.
+ * Union of all possible types from FieldType: string, number, boolean, date, array, nested.
+ * The nested-record branch's index signature tolerates `undefined` so that
+ * TypeScript optional properties (`x?: string`, carrying `string | undefined`)
+ * on EntityRow extenders typecheck without ceremony. At JSON serialization
+ * time `undefined` is equivalent to "key absent" and never appears on the
+ * wire; the inclusion here is a pure type-surface accommodation.
+ */
+type FieldValue = string | number | boolean | Date | null | string[] | FieldValue[] | {
+    [key: string]: FieldValue | undefined;
+};
+/**
+ * Runtime guard for `FieldValue` — narrows interpreter-produced `unknown`
+ * values at typed substrate boundaries (e.g. `IntegrationContext.http` body).
+ */
+declare function isFieldValue(value: RuntimeValue): value is FieldValue;
+/**
+ * One instance of an entity with actual field values.
+ * The shape is determined by the Entity definition at schema time.
+ *
+ * @example
+ * // Entity defines: Patient { fullName: string, age: number, active: boolean }
+ * // EntityRow is: { id: "p1", fullName: "Sarah", age: 34, active: true }
+ */
+type EntityRow = {
+    id?: string;
+} & Record<string, FieldValue | undefined>;
+/**
+ * A field-TYPED `EntityRow` — the SINGLE entity type, refined with a concrete
+ * field SHAPE `S`. Non-optional members of `S` are REQUIRED, each with its real
+ * type; the result stays `& EntityRow`, so the index signature is intact and
+ * every other field is still field-open — any domain entity that provides those
+ * fields satisfies it.
+ *
+ * One declaration, two jobs: (1) TypeScript enforces the bound entity has the
+ * fields WITH their types (a behavior binding a thinner/mistyped entity fails to
+ * typecheck); and (2) pattern-sync reads the same type and writes the entity
+ * prop's field shape (`properties` + `requiredFields`) onto the registry, so
+ * lolo-ui emits a COMPLETE `entity { … }` (every field, typed + demo-seeded) and
+ * the `ORB_X_ENTITY_PROP_CONTRACT` validator rejects an incompatible bind at
+ * `orbital validate`. (A raw `EntityRow & { rating: number }` intersection is
+ * equivalent for one-off shapes.)
+ *
+ * @example
+ * // HeroOrganism renders entity.title / entity.subtitle:
+ * entity?: EntityWith<{ title: string; subtitle?: string }>;
+ * //   entity.title    → string                  (required)
+ * //   entity.subtitle → string | undefined      (optional)
+ * //   entity.other    → FieldValue | undefined  (still field-open)
+ */
+type EntityWith<S extends object> = EntityRow & S;
+/**
+ * Collection of entity instances keyed by entity name.
+ * Used by OrbPreview mockData, OrbitalServerRuntime state, data grids, etc.
+ *
+ * @example
+ * const data: EntityData = {
+ *   Patient: [{ id: "1", fullName: "Sarah", age: 34 }],
+ *   QueueEntry: [{ id: "1", patientName: "Sarah", waitMinutes: 12 }],
+ * };
+ */
+type EntityData = Record<string, EntityRow[]>;
+
 /**
  * Pattern Types (Auto-Generated)
  *
  * DO NOT EDIT MANUALLY — regenerated by almadar-pattern-sync `patterns` command.
  *
- * Generated: 2026-07-28T14:48:23.870Z
- * Pattern count: 271
+ * Generated: 2026-07-29T19:32:01.969Z
+ * Pattern count: 268
  */
 
 /**
@@ -764,7 +2267,7 @@ type PatternPropValue = Record<string, FieldValue | undefined>;
  * All valid pattern type names from @almadar/core/patterns registry.
  * Use this type in render-ui effects for compile-time validation.
  */
-type PatternType = 'about-page-template' | 'accordion' | 'action-palette' | 'action-tile' | 'activation-block' | 'alert' | 'algorithm-canvas' | 'animated-counter' | 'animated-graphic' | 'animated-reveal' | 'article-section' | 'aside' | 'atlas-image' | 'atlas-panel' | 'auth-layout' | 'avatar' | 'badge' | 'behavior-view' | 'biology-canvas' | 'bloom-quiz-block' | 'book-chapter-view' | 'book-cover-page' | 'book-nav-bar' | 'book-table-of-contents' | 'book-viewer' | 'box' | 'branching-logic-builder' | 'breadcrumb' | 'button' | 'calendar-grid' | 'canvas' | 'canvas-2d' | 'card' | 'carousel' | 'case-study-card' | 'case-study-organism' | 'center' | 'chart' | 'chart-legend' | 'chat-bar' | 'checkbox' | 'chemistry-canvas' | 'choice-button' | 'code-block' | 'code-runner-panel' | 'community-links' | 'conditional-wrapper' | 'confetti-effect' | 'confirm-dialog' | 'connection-block' | 'container' | 'content-renderer' | 'content-section' | 'control-button' | 'control-grid' | 'counter-template' | 'cta-banner' | 'dashboard-grid' | 'dashboard-layout' | 'data-grid' | 'data-list' | 'date-range-picker' | 'date-range-selector' | 'day-cell' | 'detail-panel' | 'dialog' | 'dialogue-bubble' | 'divider' | 'doc-breadcrumb' | 'doc-pagination' | 'doc-search' | 'doc-sidebar' | 'doc-toc' | 'document-viewer' | 'draw-shape' | 'draw-shape-layer' | 'draw-sprite' | 'draw-sprite-layer' | 'draw-text' | 'draw-text-layer' | 'drawer' | 'drawer-slot' | 'edge-decoration' | 'empty-state' | 'entity-cards' | 'entity-list' | 'entity-table' | 'error-boundary' | 'error-state' | 'feature-card' | 'feature-detail-page-template' | 'feature-grid' | 'feature-grid-organism' | 'file-tree' | 'filter-group' | 'filter-pill' | 'flex' | 'flip-card' | 'flip-container' | 'floating-action-button' | 'form' | 'form-actions' | 'form-field' | 'form-layout' | 'form-section' | 'form-section-header' | 'game-audio-toggle' | 'game-hud' | 'game-icon' | 'game-menu' | 'game-shell' | 'generic-app-template' | 'geometric-pattern' | 'gradient-divider' | 'graph-canvas' | 'graph-view' | 'grid' | 'header' | 'health-bar' | 'hero-organism' | 'hero-section' | 'hstack' | 'icon' | 'import-preview-tree' | 'import-progress' | 'import-source-picker' | 'infinite-scroll-sentinel' | 'input' | 'input-group' | 'install-box' | 'jazari-state-machine' | 'label' | 'landing-page-template' | 'law-reference-tooltip' | 'learning-canvas' | 'lightbox' | 'likert-scale' | 'line-chart' | 'loading-state' | 'map-view' | 'markdown-content' | 'marketing-footer' | 'marketing-stat-card' | 'master-detail' | 'master-detail-layout' | 'math-canvas' | 'matrix-question' | 'media-gallery' | 'menu' | 'meter' | 'modal' | 'modal-slot' | 'module-card' | 'navigation' | 'notification' | 'number-stepper' | 'option-constraint-group' | 'orbital-visualization' | 'overlay' | 'page-header' | 'page-transition' | 'pagination' | 'pattern-tile' | 'physics-canvas' | 'popover' | 'positioned-canvas' | 'presence' | 'pricing-card' | 'pricing-grid' | 'pricing-organism' | 'pricing-page-template' | 'progress-bar' | 'progress-dots' | 'pull-quote' | 'pull-to-refresh' | 'qr-scanner' | 'quiz-block' | 'radio' | 'range-slider' | 'reflection-block' | 'relation-select' | 'repeatable-form-section' | 'reply-tree' | 'rich-block-editor' | 'runtime-debugger' | 'scaled-diagram' | 'score-display' | 'search-input' | 'section' | 'section-header' | 'segment-renderer' | 'select' | 'sequence-bar' | 'service-catalog' | 'showcase-card' | 'showcase-organism' | 'side-panel' | 'sidebar' | 'signature-pad' | 'simple-grid' | 'skeleton' | 'social-proof' | 'sortable-list' | 'spacer' | 'sparkline' | 'spinner' | 'split' | 'split-pane' | 'split-section' | 'stack' | 'star-rating' | 'stat-badge' | 'stat-card' | 'stat-display' | 'state-graph' | 'state-json-view' | 'state-machine-view' | 'stats-grid' | 'stats-organism' | 'status-dot' | 'step-flow' | 'step-flow-organism' | 'subagent-trace-panel' | 'svg-branch' | 'svg-connection' | 'svg-draw-group' | 'svg-draw-shape' | 'svg-draw-shape-layer' | 'svg-draw-text' | 'svg-flow' | 'svg-grid' | 'svg-lobe' | 'svg-mesh' | 'svg-morph' | 'svg-node' | 'svg-pulse' | 'svg-ring' | 'svg-shield' | 'svg-stack' | 'svg-stage' | 'swipeable-row' | 'switch' | 'tabbed-container' | 'table-view' | 'tabs' | 'tag-cloud' | 'tag-input' | 'team-card' | 'team-organism' | 'text-highlight' | 'textarea' | 'theme-toggle' | 'time-slot-cell' | 'timeline' | 'timer-display' | 'toast-slot' | 'tooltip' | 'trait-frame' | 'trait-slot' | 'trend-indicator' | 'typewriter-text' | 'typography' | 'ui-slot-renderer' | 'upload-drop-zone' | 'version-diff' | 'violation-alert' | 'vote-stack' | 'vstack' | 'wizard-container' | 'wizard-navigation' | 'wizard-progress';
+type PatternType = 'about-page-template' | 'accordion' | 'action-palette' | 'action-tile' | 'activation-block' | 'alert' | 'algorithm-canvas' | 'animated-counter' | 'animated-graphic' | 'animated-reveal' | 'article-section' | 'aside' | 'atlas-image' | 'atlas-panel' | 'auth-layout' | 'avatar' | 'badge' | 'behavior-view' | 'biology-canvas' | 'bloom-quiz-block' | 'book-chapter-view' | 'book-cover-page' | 'book-nav-bar' | 'book-table-of-contents' | 'book-viewer' | 'box' | 'branching-logic-builder' | 'breadcrumb' | 'button' | 'calendar-grid' | 'canvas' | 'canvas-2d' | 'card' | 'carousel' | 'case-study-card' | 'case-study-organism' | 'center' | 'chart' | 'chart-legend' | 'chat-bar' | 'checkbox' | 'chemistry-canvas' | 'choice-button' | 'code-block' | 'code-runner-panel' | 'community-links' | 'conditional-wrapper' | 'confetti-effect' | 'confirm-dialog' | 'connection-block' | 'container' | 'content-renderer' | 'content-section' | 'control-button' | 'control-grid' | 'counter-template' | 'cta-banner' | 'dashboard-grid' | 'dashboard-layout' | 'data-grid' | 'data-list' | 'date-range-picker' | 'date-range-selector' | 'day-cell' | 'detail-panel' | 'dialog' | 'dialogue-bubble' | 'divider' | 'doc-breadcrumb' | 'doc-pagination' | 'doc-search' | 'doc-sidebar' | 'doc-toc' | 'document-viewer' | 'draw-group' | 'draw-shape' | 'draw-shape-layer' | 'draw-sprite' | 'draw-sprite-layer' | 'draw-text' | 'draw-text-layer' | 'drawer' | 'drawer-slot' | 'edge-decoration' | 'emoji-picker' | 'empty-state' | 'entity-cards' | 'entity-list' | 'entity-table' | 'error-boundary' | 'error-state' | 'feature-card' | 'feature-detail-page-template' | 'feature-grid' | 'feature-grid-organism' | 'file-tree' | 'filter-group' | 'filter-pill' | 'flex' | 'flip-card' | 'flip-container' | 'floating-action-button' | 'form' | 'form-actions' | 'form-field' | 'form-layout' | 'form-section' | 'form-section-header' | 'game-audio-toggle' | 'game-hud' | 'game-icon' | 'game-menu' | 'game-shell' | 'generic-app-template' | 'geometric-pattern' | 'gradient-divider' | 'graph-canvas' | 'graph-view' | 'grid' | 'header' | 'health-bar' | 'hero-organism' | 'hero-section' | 'hstack' | 'icon' | 'import-preview-tree' | 'import-progress' | 'import-source-picker' | 'infinite-scroll-sentinel' | 'input' | 'input-group' | 'install-box' | 'jazari-state-machine' | 'label' | 'landing-page-template' | 'law-reference-tooltip' | 'learning-canvas' | 'lightbox' | 'likert-scale' | 'line-chart' | 'loading-state' | 'map-view' | 'markdown-content' | 'marketing-footer' | 'marketing-stat-card' | 'master-detail' | 'master-detail-layout' | 'math-canvas' | 'matrix-question' | 'media-gallery' | 'menu' | 'meter' | 'modal' | 'modal-slot' | 'module-card' | 'navigation' | 'notification' | 'number-stepper' | 'option-constraint-group' | 'orbital-visualization' | 'overlay' | 'page-header' | 'page-transition' | 'pagination' | 'pattern-tile' | 'physics-canvas' | 'popover' | 'positioned-canvas' | 'presence' | 'pricing-card' | 'pricing-grid' | 'pricing-organism' | 'pricing-page-template' | 'progress-bar' | 'progress-dots' | 'pull-quote' | 'pull-to-refresh' | 'qr-scanner' | 'quiz-block' | 'radio' | 'range-slider' | 'reflection-block' | 'relation-select' | 'repeatable-form-section' | 'reply-tree' | 'rich-block-editor' | 'runtime-debugger' | 'scaled-diagram' | 'score-display' | 'search-input' | 'section' | 'section-header' | 'segment-renderer' | 'select' | 'sequence-bar' | 'service-catalog' | 'showcase-card' | 'showcase-organism' | 'side-panel' | 'sidebar' | 'signature-pad' | 'simple-grid' | 'skeleton' | 'social-proof' | 'sortable-list' | 'spacer' | 'sparkline' | 'spinner' | 'split' | 'split-pane' | 'split-section' | 'stack' | 'star-rating' | 'stat-badge' | 'stat-card' | 'stat-display' | 'state-graph' | 'state-json-view' | 'state-machine-view' | 'stats-grid' | 'stats-organism' | 'status-dot' | 'step-flow' | 'step-flow-organism' | 'subagent-trace-panel' | 'svg-branch' | 'svg-connection' | 'svg-flow' | 'svg-grid' | 'svg-lobe' | 'svg-mesh' | 'svg-morph' | 'svg-node' | 'svg-pulse' | 'svg-ring' | 'svg-shield' | 'svg-stack' | 'swipeable-row' | 'switch' | 'tabbed-container' | 'table-view' | 'tabs' | 'tag-cloud' | 'tag-input' | 'team-card' | 'team-organism' | 'text-highlight' | 'textarea' | 'theme-toggle' | 'time-slot-cell' | 'timeline' | 'timer-display' | 'toast-slot' | 'tooltip' | 'trait-frame' | 'trait-slot' | 'trend-indicator' | 'typewriter-text' | 'typography' | 'ui-slot-renderer' | 'upload-drop-zone' | 'version-diff' | 'violation-alert' | 'vote-stack' | 'vstack' | 'wizard-container' | 'wizard-navigation' | 'wizard-progress';
 /**
  * Pattern props map — each pattern type maps to its valid props interface.
  */
@@ -1127,6 +2630,8 @@ interface PatternPropsMap {
         isLoading?: boolean | string | SExpr;
         unitScale?: number | string | SExpr;
         showMinimap?: boolean | string | SExpr;
+        fit?: boolean | string | SExpr;
+        tileWidth?: number | string | SExpr;
         backgroundImage?: unknown | PatternPropValue | string | SExpr;
         backgroundColor?: string | SExpr;
         worldWidth?: number | string | SExpr;
@@ -1161,6 +2666,8 @@ interface PatternPropsMap {
         keyUpMap?: PatternPropValue | string | SExpr;
         camera?: string | SExpr;
         scale?: number | string | SExpr;
+        tileWidth?: number | string | SExpr;
+        fit?: boolean | string | SExpr;
         showMinimap?: boolean | string | SExpr;
         followTarget?: PatternPropValue | string | SExpr;
         cameraPos?: PatternPropValue | string | SExpr;
@@ -1599,6 +3106,8 @@ interface PatternPropsMap {
         children?: ((...args: unknown[]) => unknown) | string | SExpr;
         renderItem?: ((...args: unknown[]) => unknown) | string | SExpr;
         pageSize?: number | string | SExpr;
+        sortBy?: string | SExpr;
+        sortDirection?: string | SExpr;
         look?: string | SExpr;
     };
     'date-range-picker': {
@@ -1725,6 +3234,15 @@ interface PatternPropsMap {
         error?: PatternPropValue | string | SExpr;
         className?: string | SExpr;
     };
+    'draw-group': {
+        type: 'draw-group';
+        id?: string | SExpr;
+        position: PatternPropValue | string | SExpr;
+        scale?: number | string | SExpr;
+        rotate?: number | string | SExpr;
+        opacity?: number | string | SExpr;
+        items: unknown[] | string | SExpr;
+    };
     'draw-shape': {
         type: 'draw-shape';
         id?: string | SExpr;
@@ -1738,6 +3256,7 @@ interface PatternPropsMap {
         offsetX?: number | string | SExpr;
         offsetY?: number | string | SExpr;
         points?: unknown[] | string | SExpr;
+        d?: string | SExpr;
         fill?: string | SExpr;
         stroke?: string | SExpr;
         strokeWidth?: number | string | SExpr;
@@ -1824,6 +3343,14 @@ interface PatternPropsMap {
         width?: number | string | SExpr;
         className?: string | SExpr;
     };
+    'emoji-picker': {
+        type: 'emoji-picker';
+        pickEvent?: string | SExpr;
+        position?: string | SExpr;
+        triggerIcon?: unknown | string | SExpr;
+        triggerLabel?: string | SExpr;
+        className?: string | SExpr;
+    };
     'empty-state': {
         type: 'empty-state';
         icon?: unknown | string | SExpr;
@@ -2906,6 +4433,8 @@ interface PatternPropsMap {
         position?: string | SExpr;
         trigger?: string | SExpr;
         showArrow?: boolean | string | SExpr;
+        open?: boolean | string | SExpr;
+        onOpenChange?: ((...args: unknown[]) => unknown) | string | SExpr;
         className?: string | SExpr;
     };
     'positioned-canvas': {
@@ -3633,53 +5162,6 @@ interface PatternPropsMap {
         width?: number | string | SExpr;
         height?: number | string | SExpr;
     };
-    'svg-draw-group': {
-        type: 'svg-draw-group';
-        x?: number | string | SExpr;
-        y?: number | string | SExpr;
-        scale?: number | string | SExpr;
-        rotate?: number | string | SExpr;
-        opacity?: number | string | SExpr;
-        className?: string | SExpr;
-        children?: unknown | string | SExpr;
-    };
-    'svg-draw-shape': {
-        type: 'svg-draw-shape';
-        shape: string | SExpr;
-        x: number | string | SExpr;
-        y: number | string | SExpr;
-        width?: number | string | SExpr;
-        height?: number | string | SExpr;
-        radius?: number | string | SExpr;
-        radiusY?: number | string | SExpr;
-        points?: string | SExpr;
-        d?: string | SExpr;
-        x2?: number | string | SExpr;
-        y2?: number | string | SExpr;
-        fill?: string | SExpr;
-        stroke?: string | SExpr;
-        strokeWidth?: number | string | SExpr;
-        opacity?: number | string | SExpr;
-        className?: string | SExpr;
-    };
-    'svg-draw-shape-layer': {
-        type: 'svg-draw-shape-layer';
-        items: unknown[] | string | SExpr;
-        fill?: string | SExpr;
-        stroke?: string | SExpr;
-        strokeWidth?: number | string | SExpr;
-        opacity?: number | string | SExpr;
-    };
-    'svg-draw-text': {
-        type: 'svg-draw-text';
-        x: number | string | SExpr;
-        y: number | string | SExpr;
-        text: string | SExpr;
-        size?: number | string | SExpr;
-        fill?: string | SExpr;
-        anchor?: string | SExpr;
-        className?: string | SExpr;
-    };
     'svg-flow': {
         type: 'svg-flow';
         points?: unknown[] | string | SExpr;
@@ -3821,20 +5303,6 @@ interface PatternPropsMap {
         svgWidth?: number | string | SExpr;
         svgHeight?: number | string | SExpr;
     };
-    'svg-stage': {
-        type: 'svg-stage';
-        cols: number | string | SExpr;
-        rows: number | string | SExpr;
-        tileSize?: number | string | SExpr;
-        background?: string | SExpr;
-        tileClickEvent?: string | SExpr;
-        tileHoverEvent?: string | SExpr;
-        tileLeaveEvent?: string | SExpr;
-        keyMap?: PatternPropValue | string | SExpr;
-        keyUpMap?: PatternPropValue | string | SExpr;
-        className?: string | SExpr;
-        children?: unknown | string | SExpr;
-    };
     'swipeable-row': {
         type: 'swipeable-row';
         leftActions?: unknown[] | string | SExpr;
@@ -3879,6 +5347,7 @@ interface PatternPropsMap {
         fields?: unknown[] | string | SExpr;
         itemActions?: unknown[] | string | SExpr;
         maxInlineActions?: number | string | SExpr;
+        itemClickEvent?: string | SExpr;
         selectable?: boolean | string | SExpr;
         selectEvent?: string | SExpr;
         selectedIds?: unknown[] | string | SExpr;
@@ -4376,7 +5845,7 @@ interface EmitConfig {
  * @example ['set', '@entity.id', 'health', 100]                 // 4-element
  * @example ['set', '@entity.id', 'count', ['+', '@entity.count', 1]]
  */
-type SetEffect = ['set', string, unknown] | ['set', string, string, unknown];
+type SetEffect = ['set', string, SExpr] | ['set', string, string, SExpr];
 /**
  * Trailing config object on persist effects. When present, it carries the
  * `emit` map specifying which events to fire on persist success/failure.
@@ -4391,12 +5860,14 @@ type PersistEmitConfig = {
     };
 };
 /**
- * Persist effect data argument: either an entity row literal (field map)
- * or a binding string referencing a row in scope (e.g. `@payload.data`,
- * `@entity`). At runtime, binding strings resolve to `EntityRow` values
- * before the persist op runs.
+ * Persist effect data argument: an entity row literal (field map), a
+ * binding string referencing a row in scope (e.g. `@payload.data`,
+ * `@entity`), or an expression form that evaluates to a row (e.g.
+ * `["object/merge", "@payload.data", { sender: "@user.id" }]`). At
+ * runtime, binding strings and expressions resolve to `EntityRow` values
+ * before the persist op runs — both paths evaluate the expression first.
  */
-type PersistData = EntityRow | string;
+type PersistData = EntityRow | string | SExpr[];
 /**
  * Persist effect - creates, updates, deletes, or clears entities.
  *
@@ -4508,12 +5979,12 @@ type WhenEffect = ['when', Expression, SExpr];
  * Uses SExpr to allow deeply nested conditionals.
  * @example ['let', ['temp', ['get', '@payload.value']], ['set', '@entity.value', 'temp']]
  */
-type LetEffect = ['let', [string, unknown][], ...SExpr[]];
+type LetEffect = ['let', [string, SExpr][], ...SExpr[]];
 /**
  * Log effect - logs a message for debugging.
  * @example ['log', 'User created:', '@entity.name']
  */
-type LogEffect = ['log', ...unknown[]];
+type LogEffect = ['log', ...SExpr[]];
 /**
  * Wait effect - delays execution.
  * @example ['wait', 1000] - wait 1 second
@@ -4633,7 +6104,7 @@ type EvaluateEffect = ['evaluate', EvaluateConfig];
  * Checkpoint save effect - saves model weights.
  * @example ['checkpoint/save', '/path/to/model.pt', '@entity.weights']
  */
-type CheckpointSaveEffect = ['checkpoint/save', string, unknown];
+type CheckpointSaveEffect = ['checkpoint/save', string, SExpr];
 /**
  * Checkpoint load effect - loads model weights.
  * @example ['checkpoint/load', '/path/to/model.pt']
@@ -4767,9 +6238,12 @@ type TypedEffect = RenderUIEffect | NavigateEffect | EmitEffect | SetEffect | Pe
  */
 type Effect = TypedEffect;
 /**
- * Schema for Effect - validates S-expression format
+ * Schema for Effect - validates S-expression format. Arguments validate as
+ * s-expr-shaped DATA (`SExprDataSchema`) — literal data arrays (empty or
+ * non-operator-headed) are valid argument values; the operator-head refine
+ * applies to the effect itself, not to every argument.
  */
-declare const EffectSchema: z.ZodEffects<z.ZodArray<z.ZodUnknown, "many">, unknown[], unknown[]>;
+declare const EffectSchema: z.ZodEffects<z.ZodArray<z.ZodType<SExpr, z.ZodTypeDef, SExpr>, "many">, SExpr[], SExpr[]>;
 type EffectInput = z.input<typeof EffectSchema>;
 /**
  * Type guard to check if a value is a valid Effect (S-expression).
@@ -4779,7 +6253,7 @@ type EffectInput = z.input<typeof EffectSchema>;
  * and subsequent elements are parameters. Used for runtime validation
  * of effect structures.
  *
- * @param {unknown} value - Value to check
+ * @param {RuntimeValue} value - Value to check
  * @returns {boolean} True if value is a valid Effect, false otherwise
  *
  * @example
@@ -4787,7 +6261,7 @@ type EffectInput = z.input<typeof EffectSchema>;
  * isEffect('not-an-effect'); // returns false
  * isEffect([]); // returns false
  */
-declare function isEffect(value: unknown): value is Effect;
+declare function isEffect(value: RuntimeValue): value is Effect;
 /**
  * Alias for isEffect (for clarity when working with S-expressions)
  */
@@ -4955,4 +6429,4 @@ interface RenderUINode {
     renderItem?: RenderUINode;
 }
 
-export { RestServiceDefSchema as $, type AnyPatternConfig as A, type BehaviorEffect as B, type CallServiceConfig as C, type DerefEffect as D, type Effect as E, type FetchEffect as F, type PatternProps as G, type PatternPropsMap as H, type PatternType as I, type PersistData as J, type PersistEffect as K, type LlmEffect as L, type McpServiceDef as M, type NavigateEffect as N, type OsEffect as O, PATTERN_TYPES as P, type PersistEmitConfig as Q, type RefEffect as R, type RenderBinding as S, type RenderChildrenMap as T, type RenderItemLambda as U, type RenderUIEffect as V, type RenderUINode as W, type ResolvedPatternProps as X, type RestAuthConfig as Y, RestAuthConfigSchema as Z, type RestServiceDef as _, type AgentEffect as a, SERVICE_TYPES as a0, type ServiceDefinition as a1, ServiceDefinitionSchema as a2, type ServiceParams as a3, type ServiceParamsValue as a4, type ServiceRef as a5, type ServiceRefObject as a6, ServiceRefObjectSchema as a7, ServiceRefSchema as a8, ServiceRefStringSchema as a9, findService as aA, getServiceNames as aB, hasService as aC, isEffect as aD, isMcpService as aE, isRestService as aF, isSExprEffect as aG, isServiceReference as aH, isServiceReferenceObject as aI, isSocketService as aJ, isValidPatternType as aK, navigate as aL, notify as aM, parseServiceRef as aN, persist as aO, ref as aP, renderUI as aQ, set as aR, spawn as aS, swap as aT, watch as aU, type ServiceType as aa, ServiceTypeSchema as ab, type SessionEffect as ac, type SetEffect as ad, type SocketEvents as ae, SocketEventsSchema as af, type SocketServiceDef as ag, SocketServiceDefSchema as ah, type SpawnEffect as ai, type SwapEffect as aj, type TraceEffect as ak, type TrainConfig as al, type TrainEffect as am, type TypedEffect as an, type UISlot as ao, UISlotSchema as ap, UI_SLOTS as aq, type ValidateEffect as ar, type WatchEffect as as, type WatchOptions as at, atomic as au, callService as av, deref as aw, despawn as ax, doEffects as ay, emit as az, type ApplicationEffect as b, type AtomicEffect as c, type CallServiceEffect as d, type CheckpointLoadEffect as e, type CheckpointSaveEffect as f, type ComposeEffect as g, type DespawnEffect as h, type DoEffect as i, type EffectInput as j, EffectSchema as k, type EmitConfig as l, type EmitEffect as m, type EvaluateConfig as n, type EvaluateEffect as o, type FetchOptions as p, type FetchResult as q, type ForwardConfig as r, type ForwardEffect as s, type LogEffect as t, McpServiceDefSchema as u, type MemoryEffect as v, type NnConfig as w, type NnLayer as x, type NotifyEffect as y, type PatternConfig as z };
+export { type ComposeEffect as $, type AnyPatternConfig as A, AssetCatalogEntrySchema as B, AssetCatalogSchema as C, type AssetDimension as D, type EntityField as E, type FieldValue as F, AssetDimensionSchema as G, AssetSchema as H, type IdentityLedger as I, type AssetUrl as J, type AtomicEffect as K, type BehaviorEffect as L, CAMERA_MODES as M, type CallServiceConfig as N, type OrbitalId as O, type PageId as P, type CallServiceEffect as Q, type RelationConfig as R, type ServiceRef as S, type TraitId as T, type UISlot as U, type Camera as V, type CameraMode as W, CameraModeSchema as X, CameraSchema as Y, type CheckpointLoadEffect as Z, type CheckpointSaveEffect as _, type EntityPersistence as a, type PersistEmitConfig as a$, type DerefEffect as a0, type DespawnEffect as a1, type DoEffect as a2, ENTITY_ROLES as a3, type EffectInput as a4, EffectSchema as a5, type EmitConfig as a6, type EmitEffect as a7, type EntityData as a8, type EntityFieldInput as a9, type LedgerKind as aA, LedgerKindSchema as aB, type LlmEffect as aC, type LogEffect as aD, type McpServiceDef as aE, McpServiceDefSchema as aF, type MemoryEffect as aG, type NavigateEffect as aH, type NnConfig as aI, type NnLayer as aJ, type NotifyEffect as aK, type ObjectEntityField as aL, type OrbitalEntity as aM, type OrbitalEntityInput as aN, OrbitalEntitySchema as aO, OrbitalIdSchema as aP, type OsEffect as aQ, PATTERN_TYPES as aR, PageIdSchema as aS, type PaletteEntryId as aT, PaletteEntryIdSchema as aU, type PatternConfig as aV, type PatternProps as aW, type PatternPropsMap as aX, type PatternType as aY, type PersistData as aZ, type PersistEffect as a_, EntityFieldSchema as aa, EntityIdSchema as ab, EntityPersistenceSchema as ac, type EntityRole as ad, EntityRoleSchema as ae, EntitySchema as af, type EntityWith as ag, type EnumEntityField as ah, type EvaluateConfig as ai, type EvaluateEffect as aj, EventIdSchema as ak, FIELD_TYPES as al, type FetchEffect as am, type FetchOptions as an, type FetchResult as ao, type Field as ap, FieldSchema as aq, type FieldType as ar, FieldTypeSchema as as, type ForwardConfig as at, type ForwardEffect as au, type IdForKind as av, type IdKind as aw, IdentityLedgerSchema as ax, type LedgerEntry as ay, LedgerEntrySchema as az, type EventId as b, VisualStyleSchema as b$, type RefEffect as b0, RelationConfigSchema as b1, type RelationEntityField as b2, type RenderChildrenMap as b3, type RenderItemLambda as b4, type RenderUINode as b5, type ResolvedPatternProps as b6, type RestAuthConfig as b7, RestAuthConfigSchema as b8, type RestServiceDef as b9, type SocketServiceDef as bA, SocketServiceDefSchema as bB, type SpawnEffect as bC, type SpriteDirection as bD, SpriteDirectionSchema as bE, type SpriteSheetAtlas as bF, type SpriteSheetAtlasInput as bG, SpriteSheetAtlasSchema as bH, type SubTexture as bI, SubTextureSchema as bJ, type SwapEffect as bK, type TextureAtlas as bL, TextureAtlasSchema as bM, type ThemeId as bN, ThemeIdSchema as bO, type Tilesheet as bP, TilesheetSchema as bQ, type TraceEffect as bR, type TrainConfig as bS, type TrainEffect as bT, TraitIdSchema as bU, type TypedEffect as bV, UISlotSchema as bW, UI_SLOTS as bX, VISUAL_STYLES as bY, type ValidateEffect as bZ, type VisualStyle as b_, RestServiceDefSchema as ba, SEMANTIC_STRING_TYPES as bb, SERVICE_TYPES as bc, SPRITE_DIRECTIONS as bd, type ScalarEntityField as be, type ScenePos as bf, ScenePosSchema as bg, type SemanticAssetRef as bh, type SemanticAssetRefInput as bi, SemanticAssetRefSchema as bj, type SemanticStringType as bk, ServiceDefinitionSchema as bl, type ServiceId as bm, ServiceIdSchema as bn, type ServiceParams as bo, type ServiceParamsValue as bp, type ServiceRefObject as bq, ServiceRefObjectSchema as br, ServiceRefSchema as bs, ServiceRefStringSchema as bt, type ServiceType as bu, ServiceTypeSchema as bv, type SessionEffect as bw, type SetEffect as bx, type SocketEvents as by, SocketEventsSchema as bz, type Effect as c, validateAssetAnimations as c$, type WatchEffect as c0, type WatchOptions as c1, asEntityId as c2, asEventId as c3, asOrbitalId as c4, asPageId as c5, asPaletteEntryId as c6, asServiceId as c7, asThemeId as c8, asTraitId as c9, isSExprEffect as cA, isSemanticStringType as cB, isSemanticStringValue as cC, isServiceId as cD, isServiceReference as cE, isServiceReferenceObject as cF, isSocketService as cG, isThemeId as cH, isTraitId as cI, isUrlValue as cJ, isUuidValue as cK, isValidPatternType as cL, ledgerCurName as cM, ledgerRename as cN, ledgerResolveName as cO, mintId as cP, navigate as cQ, notify as cR, parseAssetKey as cS, parseServiceRef as cT, persist as cU, persistenceModeAllowsOverrides as cV, ref as cW, renderUI as cX, set as cY, spawn as cZ, swap as c_, atomic as ca, callService as cb, createAssetKey as cc, deref as cd, deriveCollection as ce, despawn as cf, doEffects as cg, emit as ch, findService as ci, getDefaultAnimationsForRole as cj, getServiceNames as ck, hasService as cl, idKindOf as cm, idPrefix as cn, isEffect as co, isEmailValue as cp, isEntityId as cq, isEventId as cr, isFieldValue as cs, isMcpService as ct, isOrbitalId as cu, isPageId as cv, isPaletteEntryId as cw, isPhoneValue as cx, isRestService as cy, isRuntimeEntity as cz, type EntityId as d, watch as d0, type Entity as e, type EntityRow as f, type ServiceDefinition as g, type RenderBinding as h, type RenderUIEffect as i, ANIMATION_NAMES as j, ASSET_ASPECTS as k, ASSET_DIMENSIONS as l, type AgentEffect as m, type AnimationDef as n, type AnimationDefInput as o, AnimationDefSchema as p, type AnimationName as q, AnimationNameSchema as r, type ApplicationEffect as s, type ArrayEntityField as t, type Asset as u, type AssetAspect as v, AssetAspectSchema as w, type AssetCatalog as x, type AssetCatalogEntry as y, type AssetCatalogEntryInput as z };