@almadar/core 10.129.0 → 11.0.1

package/dist/trait-sRjIivFq.d.ts

@@ -0,0 +1,3519 @@
+import { S as SExpr, b as Expression, J as JsonValue } from './expression-DirYKz-f.js';
+import { z } from 'zod';
+import { b as EventId, F as FieldProjection, d as Effect, e as TypedEffect, T as TraitId, O as OrbitalId, E as EntityField, f as TypeVariable, g as EntityId, P as PageId, A as AnyPatternConfig, h as Entity } from './effect-DZaXwSAz.js';
+
+/**
+ * Awaiting-server skeletons — the platform-neutral contract.
+ *
+ * A server-backed trait renders through a server round trip (on entering the
+ * screen and on events that open a new view). While it waits, an empty slot
+ * (or embedded frame) shows a skeleton shaped like what the server WILL render:
+ * - every data pattern declares its natural shape as the default of its
+ *   universal `skeleton` prop, and a `.lolo` element may override it
+ *   (`skeleton: list`, `skeleton: { variant: table, rows: 6 }`, `skeleton: none`);
+ * - orbital-compiler (enrich, resolve/codegen only — never persisted) folds the
+ *   render a transition's server effects lead to into a `SkeletonNode` and
+ *   attaches it to the transition as `awaitRender`;
+ * - each execution engine marks a trait as awaiting from server-leg send until
+ *   fold or error (`AwaitingTrait`), and the shell draws the node.
+ */
+
+/** The skeleton shapes every shell can draw. */
+declare const SKELETON_VARIANTS: readonly ["header", "table", "list", "grid", "detail", "stats", "form", "card", "text"];
+type SkeletonVariant = (typeof SKELETON_VARIANTS)[number];
+declare const SkeletonVariantSchema: z.ZodEnum<{
+    header: "header";
+    form: "form";
+    detail: "detail";
+    grid: "grid";
+    card: "card";
+    list: "list";
+    text: "text";
+    stats: "stats";
+    table: "table";
+}>;
+/** A sized shape. `rows` for table/list/text, cards for grid, field pairs for detail; `columns` for table/stats; `fields` for form. */
+type SkeletonShape = {
+    variant: SkeletonVariant;
+    rows?: number;
+    columns?: number;
+    fields?: number;
+};
+declare const SkeletonShapeSchema: z.ZodObject<{
+    variant: z.ZodEnum<{
+        header: "header";
+        form: "form";
+        detail: "detail";
+        grid: "grid";
+        card: "card";
+        list: "list";
+        text: "text";
+        stats: "stats";
+        table: "table";
+    }>;
+    rows: z.ZodOptional<z.ZodNumber>;
+    columns: z.ZodOptional<z.ZodNumber>;
+    fields: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * The universal `skeleton` prop value on a render-ui node: a shape name, a
+ * sized shape, or `none` (this element contributes no skeleton).
+ */
+type SkeletonSpec = SkeletonVariant | "none" | SkeletonShape;
+declare const SkeletonSpecSchema: z.ZodUnion<readonly [z.ZodEnum<{
+    header: "header";
+    form: "form";
+    detail: "detail";
+    grid: "grid";
+    card: "card";
+    list: "list";
+    text: "text";
+    stats: "stats";
+    table: "table";
+}>, z.ZodLiteral<"none">, z.ZodObject<{
+    variant: z.ZodEnum<{
+        header: "header";
+        form: "form";
+        detail: "detail";
+        grid: "grid";
+        card: "card";
+        list: "list";
+        text: "text";
+        stats: "stats";
+        table: "table";
+    }>;
+    rows: z.ZodOptional<z.ZodNumber>;
+    columns: z.ZodOptional<z.ZodNumber>;
+    fields: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>]>;
+/** A predicted skeleton: one shape, or a vertical stack of nodes (a container's children). */
+type SkeletonNode = {
+    shape: SkeletonShape;
+} | {
+    stack: SkeletonNode[];
+};
+declare const SkeletonNodeSchema: z.ZodType<SkeletonNode>;
+/**
+ * One predicted render a transition's server effects lead to: `trait` (the seed
+ * itself, or a listener reached across the declared listens graph) will render
+ * into `slot` something shaped like `skeleton`.
+ */
+type AwaitRender = {
+    trait: string;
+    slot: string;
+    skeleton: SkeletonNode;
+};
+declare const AwaitRenderSchema: z.ZodObject<{
+    trait: z.ZodString;
+    slot: z.ZodString;
+    skeleton: z.ZodType<SkeletonNode, unknown, z.core.$ZodTypeInternals<SkeletonNode, unknown>>;
+}, z.core.$strip>;
+
+/**
+ * Represents a state in the state machine
+ */
+type State = {
+    /** State name (unique identifier) */
+    name: string;
+    /** Whether this is the initial state */
+    isInitial?: boolean;
+    /** Whether this is a terminal state (no outgoing transitions expected) */
+    isTerminal?: boolean;
+    /** Whether this is a final state (legacy alias for isTerminal) */
+    isFinal?: boolean;
+    /** Human-readable description */
+    description?: string;
+    /** Effect names to run on entry */
+    onEntry?: string[];
+    /** Effect names to run on exit */
+    onExit?: string[];
+    /** `@holds <expr>`: the trait's `@entity` satisfies it whenever the trait is in this state, proved by `orb validate`. No runtime effect. */
+    holds?: SExpr;
+};
+declare const StateSchema: z.ZodObject<{
+    name: z.ZodString;
+    isInitial: z.ZodOptional<z.ZodBoolean>;
+    isTerminal: z.ZodOptional<z.ZodBoolean>;
+    isFinal: z.ZodOptional<z.ZodBoolean>;
+    description: z.ZodOptional<z.ZodString>;
+    onEntry: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    onExit: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    holds: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+}, z.core.$strip>;
+/**
+ * Payload field definition for events
+ */
+/**
+ * One condition of a payload field's `typeWhen` conditional list: "when
+ * config knob `knob` resolves to the literal whose string spelling is
+ * `equals`, this field's type is `type`". Declared DATA — authored in
+ * `.lolo` as a type-level `match` block (§25 — REPLACED the `@typeWhen`
+ * annotation spelling outright) — never a compiler-side predicate over a
+ * specific knob name. This wire shape is `match`'s lowered form, unchanged.
+ * Mirrors Rust `PayloadTypeWhen`.
+ */
+type PayloadTypeWhen = {
+    knob: string;
+    equals: string;
+    type: string;
+};
+declare const PayloadTypeWhenSchema: z.ZodType<PayloadTypeWhen>;
+type PayloadField = {
+    name: string;
+    /**
+     * Field type. Mirrors the Rust validator's acceptance: any non-empty
+     * string. Primitives ('string' | 'number' | 'boolean' | 'object' |
+     * 'array') are the canonical values; entity-name references like
+     * 'CartItem' and array-of-entity references like '[CartItem]' are also
+     * valid because the Rust IR's PayloadField.field_type is just a String.
+     */
+    type: string;
+    required?: boolean;
+    nullable?: boolean;
+    /** Human-readable description. Mirrors Rust `PayloadField.description`. */
+    description?: string;
+    additionalProperties?: PayloadField;
+    /** Closed value set (`"a" | "b"`) — element-wise for an array type. Mirrors Rust `PayloadField.values`. */
+    values?: ReadonlyArray<string>;
+    /** Structured property schema for object-typed payload fields (recursive). */
+    properties?: ReadonlyArray<PayloadField>;
+    /**
+     * Declared knob-conditional type list (`match` in `.lolo`, §25). Resolved
+     * and cleared once composed — the emitted `.orb` carries only the
+     * resolved truth, never the conditional.
+     */
+    typeWhen?: ReadonlyArray<PayloadTypeWhen>;
+    /**
+     * The declared entity this field's value IS an instance of — stamped by
+     * lowering when an entity-typed payload field (`row: Note`, scalar or
+     * `[Note]` array — the array form names the element entity) is flattened
+     * into `type: "object"`/`"[object]"` + `properties`. Mirrors Rust
+     * `PayloadField.entity`. Absent for an anonymous struct/object field with
+     * no declared entity — never inferred from shape or name.
+     */
+    entity?: string;
+    /**
+     * `.lolo` `T.f` / `[T.f]`: the declared field this field's value — each
+     * element's, for an array type — was projected from. Mirrors Rust
+     * `PayloadField.projected_from`.
+     */
+    projectedFrom?: FieldProjection;
+    /**
+     * The element type of an `array` field whose element is itself a typed field (a union of named types:
+     * `[(Adv | string)]`), the nested form an entity field's `items` takes. Mirrors Rust `PayloadField.items`.
+     */
+    items?: PayloadField;
+};
+/**
+ * The container a payload field's `type` string declares. `[X]` (and the
+ * bare `array` primitive) is an array of `X`; `Map<K,V>` carries key/value
+ * types; `object` is a plain object;
+ * every other spelling — scalars, entity names, `@entity`, type variables,
+ * unions — is opaque to a container check.
+ */
+type PayloadTypeContainer = {
+    kind: 'array';
+    element: string;
+} | {
+    kind: 'map';
+    key: string;
+    value: string;
+} | {
+    kind: 'object';
+} | {
+    kind: 'opaque';
+};
+declare function payloadTypeContainer(type: string): PayloadTypeContainer;
+declare const PayloadFieldSchema: z.ZodType<PayloadField>;
+/** What an inbound event declares: the hook name it receives and the event whose payload answers the request. */
+type InboundDeclaration = {
+    name: string;
+    answers: string;
+    /** The sender check the runtime makes before the handler runs; its result is the payload's `verified`. */
+    verifies?: InboundVerification;
+};
+/** `verifies "<header>" "<CREDENTIAL>"`: the request header that must equal the named credential (compared in constant time, never exposed to program data). */
+type InboundVerification = {
+    header: string;
+    credential: string;
+};
+/**
+ * Represents an event that can trigger transitions
+ */
+type Event = {
+    /** Event key (UPPER_SNAKE_CASE) */
+    key: string;
+    /** V4 dual-carry id sibling of `key` — optional until the Phase-7 flip. */
+    id?: EventId;
+    /** Human-readable name */
+    name: string;
+    /** Description (authored `@description` on the emit/listen). */
+    description?: string;
+    /** User-vocabulary synonyms (comma-separated) — per-event analogue of a
+     *  field/config `@synonyms`. Feeds the curation event matcher. */
+    synonyms?: string;
+    /** Authoring tier (`essential`/`customization`/`advanced`/`internal`). */
+    tier?: string;
+    /** Expected payload structure */
+    payloadSchema?: PayloadField[];
+    /**
+     * The entity this WHOLE payload was declared as (`type X = Event
+     * <EntityName>`, the bare/concrete form) — mirrors Rust
+     * `EventDefinition.payload_entity` (G4, `Almadar_Compiler_Gaps.md` §82).
+     * Distinct from `PayloadField.entity` (a single NESTED field's value is
+     * an entity instance): this marks the payload schema ITSELF as a 1:1
+     * mirror of that entity's CURRENT fields. Consumed by
+     * `resolveTraitTypeParamSentinels` (`resolver/sentinel-resolution.ts`)
+     * to re-derive `payloadSchema` from the entity's post-`fields{}`/
+     * `extend{}` shape once an orbital-import or trait-reference override
+     * has materialized; kept in sync across entity renames the same one
+     * owner `PayloadField.entity` already uses
+     * (`renamePayloadEntityMarkers`, `reference-resolver.ts`).
+     */
+    payloadEntity?: string;
+    /**
+     * A declared input (`listens { EVENT -> input { … } }`): a client
+     * outside the program (an API, an agent, an MCP client) may send this event to
+     * the trait. Absent = not an input. Mirrors Rust `EventDefinition.input`.
+     */
+    input?: boolean;
+    /**
+     * Declared in the trait's own `listens { EVENT … }` block (the local form, input or
+     * not): an input the author offers to the program. Absent = not declared there.
+     * Mirrors Rust `EventDefinition.listened`.
+     */
+    listened?: boolean;
+    /**
+     * A declared inbound delivery (`listens { EVENT -> inbound "name" answers ANSWER { … } }`): the
+     * host carries the request at `/api/hooks/<name>` and the kernel delivers it to this event; the
+     * handler's emit of `answers` (`{ status, body }`) is the HTTP answer. Mirrors Rust
+     * `EventDefinition.inbound`.
+     */
+    inbound?: InboundDeclaration;
+    /** Domain vs System classification (optional, for analysis) */
+    classification?: "domain" | "system";
+    /** Semantic role of this event (optional, for analysis) */
+    semanticRole?: string;
+};
+declare const EventSchema: z.ZodObject<{
+    key: z.ZodString;
+    id: z.ZodOptional<z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    synonyms: z.ZodOptional<z.ZodString>;
+    tier: z.ZodOptional<z.ZodString>;
+    payloadSchema: z.ZodOptional<z.ZodArray<z.ZodType<PayloadField, unknown, z.core.$ZodTypeInternals<PayloadField, unknown>>>>;
+    payloadEntity: z.ZodOptional<z.ZodString>;
+    input: z.ZodOptional<z.ZodBoolean>;
+    listened: z.ZodOptional<z.ZodBoolean>;
+    inbound: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        answers: z.ZodString;
+        verifies: z.ZodOptional<z.ZodObject<{
+            header: z.ZodString;
+            credential: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    classification: z.ZodOptional<z.ZodEnum<{
+        domain: "domain";
+        system: "system";
+    }>>;
+    semanticRole: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Represents a named guard condition.
+ * Expression must be an S-expression.
+ *
+ * @example
+ * {
+ *   name: "hasHealth",
+ *   expression: [">", "@entity.health", 0],
+ *   description: "Check if entity has health remaining"
+ * }
+ */
+type Guard = {
+    name: string;
+    /** Guard expression - S-expression array only */
+    expression: Expression;
+    description?: string;
+};
+declare const GuardSchema: z.ZodObject<{
+    name: z.ZodString;
+    expression: z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Represents a transition between states.
+ * Guards and effects must be S-expressions.
+ *
+ * @example
+ * {
+ *   from: "idle",
+ *   to: "running",
+ *   event: "START",
+ *   guard: [">", "@entity.fuel", 0],
+ *   effects: [
+ *     ["set", "@entity.status", "running"],
+ *     ["emit", "ENGINE_STARTED"]
+ *   ]
+ * }
+ */
+type Transition = {
+    /** Source state name */
+    from: string;
+    /** Target state name */
+    to: string;
+    /** Event key that triggers this transition */
+    event: string;
+    /** V4 dual-carry id sibling of `event` — optional until the Phase-7 flip. */
+    eventId?: EventId;
+    /** Guard expression - S-expression array */
+    guard?: Expression | null;
+    /** Effects to execute - S-expression arrays */
+    effects?: Effect[];
+    /** `@ensures <expr>`: the outcome contract owed at this transition (`@fromEntity` is the row before it); proved by `orb validate`, judged by `orb verify`. No runtime effect. */
+    ensures?: SExpr[];
+    /** Description */
+    description?: string | null;
+    /**
+     * Predicted renders this transition's server effects lead to, used to draw
+     * awaiting-server skeletons. Computed by orbital-compiler (enrich) in the
+     * resolved schema only — never authored, never persisted in a registry `.orb`.
+     */
+    awaitRender?: AwaitRender[];
+};
+declare const TransitionSchema: z.ZodObject<{
+    from: z.ZodString;
+    to: z.ZodString;
+    event: z.ZodString;
+    eventId: z.ZodOptional<z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>;
+    guard: z.ZodOptional<z.ZodNullable<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>>;
+    effects: z.ZodOptional<z.ZodArray<z.ZodType<TypedEffect, unknown, z.core.$ZodTypeInternals<TypedEffect, unknown>>>>;
+    ensures: z.ZodOptional<z.ZodType<SExpr[], unknown, z.core.$ZodTypeInternals<SExpr[], unknown>>>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    awaitRender: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        trait: z.ZodString;
+        slot: z.ZodString;
+        skeleton: z.ZodType<SkeletonNode, unknown, z.core.$ZodTypeInternals<SkeletonNode, unknown>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+/**
+ * Complete state machine definition
+ */
+type StateMachine = {
+    /** All states in the machine */
+    states: State[];
+    /** All events that can be triggered */
+    events: Event[];
+    /** All transitions between states */
+    transitions: Transition[];
+    /** Named guard definitions */
+    guards?: Guard[];
+};
+declare const StateMachineSchema: z.ZodObject<{
+    states: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        isInitial: z.ZodOptional<z.ZodBoolean>;
+        isTerminal: z.ZodOptional<z.ZodBoolean>;
+        isFinal: z.ZodOptional<z.ZodBoolean>;
+        description: z.ZodOptional<z.ZodString>;
+        onEntry: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        onExit: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        holds: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+    }, z.core.$strip>>;
+    events: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        id: z.ZodOptional<z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        synonyms: z.ZodOptional<z.ZodString>;
+        tier: z.ZodOptional<z.ZodString>;
+        payloadSchema: z.ZodOptional<z.ZodArray<z.ZodType<PayloadField, unknown, z.core.$ZodTypeInternals<PayloadField, unknown>>>>;
+        payloadEntity: z.ZodOptional<z.ZodString>;
+        input: z.ZodOptional<z.ZodBoolean>;
+        listened: z.ZodOptional<z.ZodBoolean>;
+        inbound: z.ZodOptional<z.ZodObject<{
+            name: z.ZodString;
+            answers: z.ZodString;
+            verifies: z.ZodOptional<z.ZodObject<{
+                header: z.ZodString;
+                credential: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        classification: z.ZodOptional<z.ZodEnum<{
+            domain: "domain";
+            system: "system";
+        }>>;
+        semanticRole: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    transitions: z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+        event: z.ZodString;
+        eventId: z.ZodOptional<z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>;
+        guard: z.ZodOptional<z.ZodNullable<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>>;
+        effects: z.ZodOptional<z.ZodArray<z.ZodType<TypedEffect, unknown, z.core.$ZodTypeInternals<TypedEffect, unknown>>>>;
+        ensures: z.ZodOptional<z.ZodType<SExpr[], unknown, z.core.$ZodTypeInternals<SExpr[], unknown>>>;
+        description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        awaitRender: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            trait: z.ZodString;
+            slot: z.ZodString;
+            skeleton: z.ZodType<SkeletonNode, unknown, z.core.$ZodTypeInternals<SkeletonNode, unknown>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    guards: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        expression: z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+type StateInput = z.input<typeof StateSchema>;
+type EventInput = z.input<typeof EventSchema>;
+type GuardInput = z.input<typeof GuardSchema>;
+type TransitionInput = z.input<typeof TransitionSchema>;
+type StateMachineInput = z.input<typeof StateMachineSchema>;
+/**
+ * Check if an event is a circuit event (not internal/system event).
+ * Circuit events are user-defined events that participate in the closed circuit pattern.
+ * Internal/system events start with underscore (e.g., _INIT, _TICK, _TIMER).
+ *
+ * @param {string} event - Event name to check
+ * @returns {boolean} true if event is a circuit event (doesn't start with underscore)
+ *
+ * @example
+ * isCircuitEvent('CREATE') // true
+ * isCircuitEvent('SAVE') // true
+ * isCircuitEvent('_INIT') // false (internal)
+ * isCircuitEvent('_TICK') // false (internal)
+ */
+declare function isCircuitEvent(event: string): boolean;
+
+/**
+ * A single value in a trait's call-site `config: { ... }` block. Supports
+ * scalars (string, number, boolean, null), arrays (e.g. `fields: ["name",
+ * "description"]`), and nested objects. This is the authoring surface for
+ * molecules to parameterize imported atoms: the atom's render-ui reads back
+ * via `@config.<key>` bindings.
+ */
+type TraitConfigValue = string | number | boolean | null | ReadonlyArray<TraitConfigValue> | TraitConfigObject;
+type TraitConfigObject = {
+    readonly [key: string]: TraitConfigValue;
+};
+type TraitConfig = TraitConfigObject;
+/** Zod schema for TraitConfig. Recursive via z.lazy to allow nested structures. */
+declare const TraitConfigValueSchema: z.ZodType<TraitConfigValue>;
+declare const TraitConfigSchema: z.ZodType<TraitConfig>;
+/**
+ * A single entry in a call-site `config { }` override block. Either a plain
+ * wiring value (`TraitConfigValue` — string, number, bool, array, object) or
+ * a fully-annotated re-declaration (`ConfigFieldDeclaration` — carries `type`,
+ * optional `label`/`description`/`synonyms`/`tier`). Disambiguated at runtime
+ * by `isCallSiteConfigDeclaration`: the presence of a `"type"` string key
+ * marks the annotated form.
+ *
+ * The `.orb` compiler emits plain values for wiring entries and
+ * `{ type, default, ... }` objects for annotated entries. Consumers that only
+ * need the value (e.g. `apply-params-to-orb.ts`) read `entry` directly for
+ * primitives or `entry.default` for the declaration form.
+ */
+type CallSiteConfigEntry = TraitConfigValue | ConfigFieldDeclaration;
+/** Typed map of call-site config entries (one per knob). */
+type CallSiteConfig = Readonly<Record<string, CallSiteConfigEntry>>;
+/**
+ * Type guard: returns `true` when `entry` is an annotated `ConfigFieldDeclaration`
+ * (a config-field SCHEMA: a `"type"` string key AND a `"default"` value slot)
+ * rather than a plain wiring value or a render value object.
+ *
+ * The `"default"` requirement disambiguates a declaration from a `render-ui`
+ * VALUE object (e.g. `{ type: "tabs", items: "@entity.items", ... }`) that
+ * coincidentally carries a UI-component `type` key — such a value has no
+ * `default` slot and is a `TraitConfigValue`, not a schema declaration. Every
+ * annotated config field lowered from `.lolo` carries a `default`; misreading a
+ * render value as a declaration drops it straight into the `config` map where
+ * Rust's `serde` rejects its inner fields (e.g. `items` is a binding string,
+ * not a `FieldDefinition`).
+ */
+declare function isCallSiteConfigDeclaration(entry: CallSiteConfigEntry): entry is ConfigFieldDeclaration;
+/**
+ * Whether a call-site config entry RE-DECLARES its knob (legal for a knob the trait does not
+ * declare) rather than setting a value. Twin of orbital-core `ConfigField::is_declaration_form`:
+ * a value wrapped as `{ type: 'unknown', default }` (what `mergeCallSiteConfigOverrides` builds)
+ * is a value; a typed declaration, or one carrying `label`/`description`/`synonyms`/`tier`, is not.
+ */
+declare function isConfigRedeclaration(entry: CallSiteConfigEntry): boolean;
+/**
+ * Type guard: `entry` is a declared config-field SCHEMA — a string `type` plus
+ * EITHER a `default` slot OR declaration metadata (`label`/`description`/
+ * `tier`/`synonyms`/`values`). Broader than `isCallSiteConfigDeclaration`,
+ * which requires a `default`: a field declared with no default (e.g.
+ * `leftIcon : icon` → `{ type: "icon", label, description, tier }`) is still a
+ * schema, and its runtime VALUE is its (absent → `undefined`) default, NOT the
+ * schema object itself. A render-value object that coincidentally has a `type`
+ * key (e.g. `{ type: "tabs", items: … }`) carries none of these metadata keys
+ * and is therefore left untouched as a plain value.
+ */
+declare function isConfigFieldSchema(entry: CallSiteConfigEntry): entry is ConfigFieldDeclaration;
+/**
+ * Convert a call-site config map into plain runtime values.
+ *
+ * A `CallSiteConfig` may contain either plain wiring values
+ * (`TraitConfigValue`) or annotated `ConfigFieldDeclaration` objects
+ * (`{ type, default, label, ... }`). Both the JS interpreter
+ * (`@almadar/runtime`) and the render substrate (`@almadar/ui`) need this
+ * extraction, so it lives here — the most-upstream package they share —
+ * rather than being duplicated in each.
+ *
+ * A declared field with no `default` yields no value (dropped), as the
+ * kernel reads it. Leaking such a schema object through as a
+ * value made `@config.leftIcon` resolve to `{ type: "icon", … }`, which the
+ * render substrate then mounted as an element and passed to `Input`'s icon
+ * slot → "Element type is invalid: got <SlotContentRenderer />".
+ */
+declare function normalizeCallSiteConfigToValues(config: CallSiteConfig | undefined): TraitConfig | undefined;
+/**
+ * Merge call-site config overrides onto a base `CallSiteConfig`. Every entry
+ * in the result is a `ConfigField` (Rust's `HashMap<String, ConfigField>`):
+ * bare values — base AND override — are wrapped as `{ type: 'unknown', default }`
+ * when not already a declaration. Override folds into an existing declaration's
+ * `default` field.
+ */
+declare function mergeCallSiteConfigOverrides(base: CallSiteConfig, overrides: CallSiteConfig): Record<string, ConfigFieldDeclaration>;
+/**
+ * Per-field entry in a trait's DECLARED `config { }` schema as it lives
+ * on the `.orb` JSON: `{ type: "string" | "[string]" | "object" | ...,
+ * default?: <value> }`. Distinct from `TraitConfigValue` (which is the
+ * resolved runtime value). The runtime reads `default` to seed the
+ * `@config.X` binding context when no call-site override is supplied.
+ *
+ * Authored as `config { foo : string = "bar" }` in `.lolo`; lowered to
+ * `{ foo: { type: "string", default: "bar" } }` in `.orb`. The optional
+ * metadata fields below (`label`/`description`/`tier`/`values`/`synonyms`)
+ * carry the `.lolo` `@label`/`@description`/`@tier`/`@synonyms` annotations and
+ * the enum member list through lowering — consumed by config-driven UI
+ * (e.g. the playground property inspector) to render typed controls.
+ */
+/**
+ * The reference config-field types (V4-W5). A config knob typed `entity`,
+ * `trait`, or `event` holds a REFERENCE (an entity/trait/event name), not a
+ * plain value — so the stamp records the referenced node's id on the field
+ * (`ConfigFieldDeclaration.refId`) and both execution paths resolve the value to
+ * the node's CURRENT name by id, exactly like `entityRefIds`/`traitEmbedIds`.
+ * This is the deterministic, source-tagged contract that lets a declaration-only
+ * rename flow through a config value without any name-scanning heuristic.
+ */
+declare const REFERENCE_CONFIG_TYPES: readonly ["entity", "trait", "event"];
+type ReferenceConfigType = (typeof REFERENCE_CONFIG_TYPES)[number];
+/** True when a config field's `type` marks its value as an entity/trait/event reference. */
+declare function isReferenceConfigType(type: string): type is ReferenceConfigType;
+/**
+ * The secret config-field types. A config knob typed `secret` holds a
+ * credential REFERENCE (an env-var key name for `resolveCredentialRef`) —
+ * and, as defense-in-depth against a host wrongly inlining material, its
+ * VALUE must never flow into spec.json, traces, plan snapshots, or factory
+ * bakes in cleartext: consumers mask it (see `maskSecretConfigValues`) and
+ * UI password-renders the knob. `.lolo` accepts `: secret` as a config-field
+ * type (I-29, 2026-08-23 — previously the parser silently read it as a
+ * meaningless named type); this contract is the single deterministic source
+ * downstream consumers (studio, verifiers, rabit bakes) key on.
+ */
+declare const SECRET_CONFIG_TYPES: readonly ["secret"];
+type SecretConfigType = (typeof SECRET_CONFIG_TYPES)[number];
+/** True when a config field's `type` marks its value as a credential to be masked. */
+declare function isSecretConfigType(type: string): type is SecretConfigType;
+/**
+ * Return `values` with every `secret`-declared field's string value masked to
+ * its last 4 characters (shorter values fully masked). Non-secret fields and
+ * non-string values pass through untouched. Use before echoing call-site
+ * config into traces, spec snapshots, or logs.
+ */
+declare function maskSecretConfigValues(config: DeclaredTraitConfig, values: TraitConfig): TraitConfig;
+/**
+ * Fold an override value map onto a `DeclaredTraitConfig`'s per-knob
+ * `default`, mirroring the compiler's `ORB_O_CONFIG_UNKNOWN_KEY` check.
+ * Single owner for the factory-runtime overlay (`applyParamsToOrb` folding
+ * `OrbitalFactoryParams.config`) and the runtime's `OrbitalRefObject.config`
+ * fold (`reference-resolver.ts`) — same operation, two call sites.
+ *
+ * Throws when `overrides` names a key `declared` does not declare. Callers
+ * validate the override keys against the manifest / upstream config first
+ * (`validateOrbitalFactoryParams`, the resolver's own pre-check), so this is
+ * a should-never-happen guard, not a user-facing error path.
+ */
+declare function overrideDeclaredKnobs(declared: DeclaredTraitConfig, overrides: Readonly<Record<string, TraitConfigValue>>): DeclaredTraitConfig;
+type ConfigFieldDeclaration = {
+    readonly nullable?: boolean;
+    readonly additionalProperties?: EntityField;
+    readonly type: string;
+    readonly default?: TraitConfigValue;
+    /**
+     * V4-W5 dual-carry id — set by the stamp when `type` is a reference config
+     * type (`entity`/`trait`/`event`): the stable id of the entity/trait/event
+     * the field's value names. Readers resolve the value to that node's current
+     * name by id (rename-proof); absent for non-reference fields.
+     */
+    readonly refId?: string;
+    /** Marks the knob as mandatory at every call site (own-page binding exempt). `required` + `default` may coexist — the default only serves the trait's own demo page. */
+    readonly required?: boolean;
+    /** `@label` — human-readable control label. */
+    readonly label?: string;
+    /** `@description` — help/tooltip text for the field. */
+    readonly description?: string;
+    /** `@tier` — disclosure tier: `presentation`|`domain`|`policy`|`infra`|`internal`. */
+    readonly tier?: string;
+    /** Enum members when the field's type is a string union — drives a select control. */
+    readonly values?: ReadonlyArray<string>;
+    /** `@synonyms` — comma-separated vocabulary synonyms (metadata). */
+    readonly synonyms?: string;
+    /** Structured per-item schema for array-of-object fields — `edges : [{from: string!, …}]` in `.lolo` lowers to `{ type: "object", properties: {…} }`. */
+    readonly items?: ConfigFieldItemsDeclaration;
+    /** Structured property schema for object-typed config fields (no items wrapper). */
+    readonly properties?: Readonly<Record<string, TraitEntityField>>;
+    /**
+     * Provenance for a collapsed knob forward. The L2 inline phase (and the
+     * runtime resolver) fold a trait's `default: "@config.<knob>"` (or a
+     * call-site override of the same shape) down to the resolved value, so
+     * the resolved schema no longer carries the literal `@config.<knob>`
+     * token anywhere. `forwardedFrom` records that token — the original
+     * app/orbital-level knob name this field's value came from — so a
+     * dead-knob check (`ORB_O_CONFIG_DEAD_KNOB` / `orbital-config-knob-unforwarded`)
+     * can still recognize the knob as forwarded on an already-resolved
+     * schema. Absent when the field's `default`/value was authored directly
+     * (not a forward), or on an unresolved schema where the `@config.<knob>`
+     * token itself is still present.
+     */
+    readonly forwardedFrom?: string;
+    /**
+     * The `@config.<knob>` tokens nested INSIDE this field's value (an array
+     * element or object member, e.g. `metrics[].target`) that the resolver
+     * folded to their values — the list twin of `forwardedFrom`, so the
+     * dead-knob check still sees those knobs as read. Absent when nothing
+     * nested resolved. Compiled-path wire key `nestedForwardedFrom`.
+     */
+    readonly nestedForwardedFrom?: ReadonlyArray<string>;
+    /**
+     * The definer knob this field is the payload companion of, when its
+     * declared type was `@payload(<knob>)`: the L2 sigil pass rewrites the
+     * sentinel to the resolved payload type and records the knob here, the
+     * same way `forwardedFrom` keeps a provenance the resolved `default` /
+     * `type` can no longer show. Absent for any field that was never a
+     * `@payload(<knob>)` sentinel. Compiled-path wire key `payloadFor`.
+     */
+    readonly payloadFor?: string;
+    /** `.lolo` `T.f`: the declared field this knob's type was projected from. */
+    readonly projectedFrom?: FieldProjection;
+    /** `field R T`: the record `R` as a type string (`@entity`, `@payload(knob)`, an entity or alias name, `$r`). */
+    readonly record?: string;
+    /** A call-site entry that wires a value into a knob the trait declares; `type` then carries the SOURCE knob's type (`unknown` for a literal). */
+    readonly wired?: boolean;
+};
+type ConfigFieldItemsDeclaration = {
+    readonly nullable?: boolean;
+    readonly additionalProperties?: EntityField;
+    readonly type?: string;
+    /** Absent for arrays of scalars (`items: { type: "string" }`). */
+    readonly properties?: Readonly<Record<string, TraitEntityField>>;
+    /** Nested per-item schema for arrays of arrays (recursive). */
+    readonly items?: ConfigFieldItemsDeclaration;
+    /** Union member names when the item type is a union — including a by-name recursive back-reference. */
+    readonly values?: ReadonlyArray<string>;
+};
+declare const ConfigFieldDeclarationSchema: z.ZodType<ConfigFieldDeclaration, object>;
+/**
+ * Map of declared config fields keyed by name. Lives on `Trait.config`
+ * for atoms/molecules that expose typed configuration to consumers.
+ */
+type DeclaredTraitConfig = Readonly<Record<string, ConfigFieldDeclaration>>;
+declare const DeclaredTraitConfigSchema: z.ZodType<DeclaredTraitConfig, Record<string, object>>;
+/**
+ * Field types for trait data entities
+ */
+type TraitFieldType = 'string' | 'number' | 'boolean' | 'date' | 'array' | 'object' | 'timestamp' | 'datetime' | 'instant' | 'enum' | 'email' | 'url' | 'phone' | 'uuid' | 'image' | 'bytes' | 'trait' | 'slot' | 'pattern' | 'node' | 'event' | 'EventAddress' | 'CallKey' | 'SExpr' | 'union' | 'tuple' | 'field' | TypeVariable;
+/**
+ * Simplified field for trait data entities
+ */
+type TraitEntityField = {
+    nullable?: boolean;
+    additionalProperties?: EntityField;
+    name: string;
+    type: TraitFieldType;
+    required?: boolean;
+    /** Field default parsed from `.orb` — always a JSON-shaped value. */
+    default?: TraitConfigValue;
+    values?: string[];
+    /** Structured per-item schema for array-of-object fields (recursive). */
+    items?: ConfigFieldItemsDeclaration;
+    /** Structured property schema for object-typed entity fields. */
+    properties?: Readonly<Record<string, TraitEntityField>>;
+    /** `@payload(.<sibling>)`: an `object` with no `properties` is the declared payload of the event its sibling member names. */
+    record?: string;
+};
+declare const TraitEntityFieldSchema: z.ZodType<TraitEntityField, object>;
+/**
+ * Simplified data entity for traits
+ */
+type TraitDataEntity = {
+    name: string;
+    collection?: string;
+    fields: TraitEntityField[];
+    timestamps?: boolean;
+    description?: string;
+    runtime?: boolean;
+    singleton?: boolean;
+    pages?: string[];
+};
+declare const TraitDataEntitySchema: z.ZodObject<{
+    name: z.ZodString;
+    collection: z.ZodOptional<z.ZodString>;
+    fields: z.ZodArray<z.ZodType<TraitEntityField, object, z.core.$ZodTypeInternals<TraitEntityField, object>>>;
+    timestamps: z.ZodOptional<z.ZodBoolean>;
+    description: z.ZodOptional<z.ZodString>;
+    runtime: z.ZodOptional<z.ZodBoolean>;
+    singleton: z.ZodOptional<z.ZodBoolean>;
+    pages: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * Tick rule for traits.
+ * Guards can be legacy strings or S-expressions.
+ * Effects can be typed Effect objects or S-expressions.
+ */
+type TraitTick = {
+    name: string;
+    description?: string;
+    priority?: number;
+    interval: string | number;
+    appliesTo?: string[];
+    /** `[background]`: runs with no client mounted; otherwise paused while no client has the trait mounted. */
+    runsInBackground?: boolean;
+    /** `[visible]`: a browser tick that pauses while its trait's rendered output is off screen. */
+    whileVisible?: boolean;
+    pages?: string[];
+    /** V4 dual-carry id sibling of `pages` — optional until the Phase-7 flip. */
+    pageIds?: PageId[];
+    /** Guard expression - string (legacy) or S-expression array */
+    guard?: Expression;
+    /** Effects to execute (S-expressions) */
+    effects: Effect[];
+    /**
+     * Events this tick emits.
+     * Must reference events defined in trait's emits array.
+     * Used for validation and documentation.
+     */
+    emits?: string[];
+    /** V4 dual-carry id sibling of `emits` — optional until the Phase-7 flip. */
+    emitIds?: EventId[];
+};
+/**
+ * A tick's cadence: `"frame"`, a positive number of milliseconds, a duration
+ * string, or a cron expression.
+ *
+ * This schema previously accepted only `"frame"` or a number, while `TraitTick`
+ * declared `string | number` and the kernel's tick clock already parsed durations and cron
+ * (`TickClock` → `cron::parse_cron`).
+ * The gate therefore rejected every cron/duration tick before its runtime could
+ * run it — `std-data-erasure`'s hourly `executionScan` made the whole orbital
+ * unloadable in the interpreter with only `traits.N: Invalid input` to go on.
+ */
+declare const TickIntervalSchema: z.ZodUnion<readonly [z.ZodLiteral<"frame">, z.ZodNumber, z.ZodString]>;
+declare const TraitTickSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    priority: z.ZodOptional<z.ZodNumber>;
+    interval: z.ZodUnion<readonly [z.ZodLiteral<"frame">, z.ZodNumber, z.ZodString]>;
+    appliesTo: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    runsInBackground: z.ZodOptional<z.ZodBoolean>;
+    whileVisible: z.ZodOptional<z.ZodBoolean>;
+    pages: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    pageIds: z.ZodOptional<z.ZodArray<z.ZodString & z.ZodType<PageId, string, z.core.$ZodTypeInternals<PageId, string>>>>;
+    guard: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+    effects: z.ZodArray<z.ZodType<TypedEffect, unknown, z.core.$ZodTypeInternals<TypedEffect, unknown>>>;
+    emits: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    emitIds: z.ZodOptional<z.ZodArray<z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>>;
+}, z.core.$strip>;
+/**
+ * Event scope determines visibility:
+ * - 'internal': Trait-to-trait within same orbital (default)
+ * - 'external': Exposed for cross-orbital communication
+ */
+type EventScope = 'internal' | 'external';
+declare const EventScopeSchema: z.ZodEnum<{
+    external: "external";
+    internal: "internal";
+}>;
+/**
+ * Payload field definition for events: the one {@link PayloadField} (Rust `PayloadField`),
+ * re-exported under the event-contract name.
+ */
+type EventPayloadField = PayloadField;
+declare const EventPayloadFieldSchema: z.ZodType<EventPayloadField>;
+/**
+ * Event contract for events a trait emits.
+ * Declares the event name, scope, and payload schema.
+ */
+type TraitEventContract = {
+    /** Event name (UPPER_SNAKE_CASE) */
+    event: string;
+    /** V4 dual-carry id sibling of `event` — optional until the Phase-7 flip. */
+    eventId?: EventId;
+    /** Human-readable description */
+    description?: string;
+    /** User-vocabulary synonyms (comma-separated) — the per-event analogue of a
+     *  field/config `@synonyms`. Feeds the curation event matcher. */
+    synonyms?: string;
+    /** Authoring tier (`essential`/`customization`/`advanced`/`internal`). */
+    tier?: string;
+    /**
+     * The config knob whose value DEFINES this event's name, when the emit was
+     * authored as `emits { @config.<knob> }`. Captured at L1, where the
+     * `@config.X` spelling still exists — after inlining, `event` holds the
+     * resolved literal and the fact that it came from a knob is otherwise
+     * unrecoverable.
+     *
+     * A definer knob CREATES an event name rather than referencing one, which
+     * is why consumers must not pin such a knob to the trait's existing event
+     * vocabulary: doing so forbids the very name it exists to introduce.
+     */
+    definerKnob?: string;
+    /**
+     * `true` when `scope` was set by a CALL-SITE `emitsScope` override (the
+     * inline phase applies it), not by the source atom's own `-> external`
+     * declaration. An atom declaring its emits external is an unexamined
+     * default (nearly every atom does), while a composition restating it is
+     * the consumer's own deferral — the dead-control check honours it as an
+     * exemption. See ORB-X-EXTERNAL-EMIT-EXEMPTION.
+     */
+    scopeOverridden?: boolean;
+    /** Payload schema — declarative type info for the event's payload.
+     *  Distinct from the runtime payload value (`@payload.X` bindings,
+     *  `EventPayload`) which is a separate concept. */
+    payloadSchema?: EventPayloadField[];
+    /**
+     * Same marker as `Event.payloadEntity` (`state-machine.ts`) — this
+     * emit's payload was declared `type X = Event <EntityName>` and is a
+     * flat mirror of that entity's fields. See that field's doc for the
+     * full contract (G4, `Almadar_Compiler_Gaps.md` §82).
+     */
+    payloadEntity?: string;
+    /**
+     * Event scope:
+     * - 'internal': Trait-to-trait within same orbital (default)
+     * - 'external': Exposed for cross-orbital communication
+     */
+    scope?: EventScope;
+};
+/**
+ * `@config.<knob>` is the only legal reference form for an emit/listen
+ * event name (Option B — the declared event name resolves to a
+ * `string`- or `event`-typed config knob's value at inline/resolve time).
+ * Matches the Rust lexer's dotted-sigil body (`config.<ident>`, no further
+ * dots).
+ */
+declare const CONFIG_REF_EVENT_PATTERN: RegExp;
+/** Returns the knob identifier when `event` is a `@config.<knob>` reference, else `undefined`. */
+declare function configRefEventKnob(event: string): string | undefined;
+/** Why a `@config.<knob>` emit/listen event-name reference failed to resolve. */
+type ConfigRefEventError = 'unknown-knob' | 'not-string' | 'no-default';
+/**
+ * Resolve a `@config.<knob>` emit/listen event-name reference to its
+ * concrete literal, given the trait's declared config schema and the
+ * effective config value map (call-site override folded over declared
+ * default — same precedence the Rust inline phase's `effective_config`
+ * uses). The single JS-side owner of this resolution rule; mirrors
+ * `resolve_config_ref_event_name` in `orbital-core::schema` (Rust).
+ * Returns the resolved literal, or the specific contract clause that failed.
+ */
+declare function resolveConfigRefEventName(event: string, declaredConfig: DeclaredTraitConfig | undefined, effectiveConfig: Readonly<Record<string, TraitConfigValue>>): {
+    readonly ok: true;
+    readonly value: string;
+} | {
+    readonly ok: false;
+    readonly error: ConfigRefEventError;
+};
+declare const TraitEventContractSchema: z.ZodObject<{
+    event: z.ZodString;
+    eventId: z.ZodOptional<z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>;
+    description: z.ZodOptional<z.ZodString>;
+    synonyms: z.ZodOptional<z.ZodString>;
+    tier: z.ZodOptional<z.ZodString>;
+    definerKnob: z.ZodOptional<z.ZodString>;
+    scopeOverridden: z.ZodOptional<z.ZodBoolean>;
+    payloadSchema: z.ZodOptional<z.ZodArray<z.ZodType<PayloadField, unknown, z.core.$ZodTypeInternals<PayloadField, unknown>>>>;
+    payloadEntity: z.ZodOptional<z.ZodString>;
+    scope: z.ZodOptional<z.ZodEnum<{
+        external: "external";
+        internal: "internal";
+    }>>;
+}, z.core.$strip>;
+/**
+ * Event listener for trait communication.
+ * Guards can be legacy strings or S-expressions.
+ * Enhanced with scope and payloadMapping for cross-orbital communication.
+ */
+/**
+ * Source-scoping for a `listens {}` entry. Determines which emitters the
+ * listener responds to.
+ *
+ * - `{ kind: "any" }`: wildcard (`* EVENT -> TRIGGER`). Any trait, any orbital.
+ * - `{ kind: "trait", trait: "X" }`: intra-orbital (`X EVENT -> TRIGGER`).
+ *   Only emits from the same orbital's trait `X`.
+ * - `{ kind: "orbital", orbital: "O", trait: "X" }`: cross-orbital
+ *   (`O.X EVENT -> TRIGGER`). Only emits from orbital `O`'s trait `X`.
+ *
+ * Absent (undefined) means the listener is a local payload-declaration only
+ * — pure type metadata, no bus subscription.
+ */
+type ListenSource = {
+    kind: 'any';
+} | {
+    kind: 'trait';
+    trait: string;
+    /** V4 dual-carry id sibling of `trait` — optional until the Phase-7 flip. */
+    traitId?: TraitId;
+} | {
+    kind: 'orbital';
+    orbital: string;
+    trait: string;
+    /** V4 dual-carry id sibling of `orbital` — optional until the Phase-7 flip. */
+    orbitalId?: OrbitalId;
+    /** V4 dual-carry id sibling of `trait` — optional until the Phase-7 flip. */
+    traitId?: TraitId;
+};
+declare const ListenSourceSchema: z.ZodUnion<readonly [z.ZodObject<{
+    kind: z.ZodLiteral<"any">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"trait">;
+    trait: z.ZodString;
+    traitId: z.ZodOptional<z.ZodString & z.ZodType<TraitId, string, z.core.$ZodTypeInternals<TraitId, string>>>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"orbital">;
+    orbital: z.ZodString;
+    trait: z.ZodString;
+    orbitalId: z.ZodOptional<z.ZodString & z.ZodType<OrbitalId, string, z.core.$ZodTypeInternals<OrbitalId, string>>>;
+    traitId: z.ZodOptional<z.ZodString & z.ZodType<TraitId, string, z.core.$ZodTypeInternals<TraitId, string>>>;
+}, z.core.$strip>]>;
+/**
+ * Split a `listens`-addressed event (`EVENT`, `Trait.EVENT`, `*.EVENT`,
+ * `Orbital.Trait.EVENT`) into the bare event and its source. The one parser of
+ * the address form, shared by `listens` and event-typed values. Mirrors
+ * `orbital-core` `split_event_address`.
+ */
+declare function splitEventAddress(raw: string): {
+    event: string;
+    source?: ListenSource;
+};
+/** Inverse of {@link splitEventAddress}. */
+declare function joinEventAddress(event: string, source?: ListenSource): string;
+type TraitEventListener = {
+    /** Event key to listen for (bare event name, no source prefix in the new shape) */
+    event: string;
+    /** V4 dual-carry id sibling of `event` — optional until the Phase-7 flip. */
+    eventId?: EventId;
+    /** State machine event to trigger */
+    triggers: string;
+    /** V4 dual-carry id sibling of `triggers` — optional until the Phase-7 flip. */
+    triggersId?: EventId;
+    /** Human-readable description (authored `@description` on the listen). */
+    description?: string;
+    /** User-vocabulary synonyms (comma-separated). */
+    synonyms?: string;
+    /** Authoring tier (`essential`/`customization`/`advanced`/`internal`). */
+    tier?: string;
+    /** Guard expression - string (legacy) or S-expression array */
+    guard?: Expression;
+    /**
+     * Listener scope:
+     * - 'internal': Listen to events within same orbital (default)
+     * - 'external': Listen to events from other orbitals
+     */
+    scope?: EventScope;
+    /**
+     * `with { ... }` payload rewrite: `{ targetField: SExpr }`. Each value is a
+     * full s-expression evaluated against the source payload — a `@payload.<field>`
+     * read, a literal, or an operator list. The kernel applies it
+     * (`applyListenMapping` crosses into it).
+     */
+    payloadMapping?: Record<string, SExpr>;
+    /**
+     * `per <expr>`: the row of the listening entity this delivery steps, an s-expression over the source payload that
+     * must evaluate to a non-empty string. The kernel evaluates it and creates the row on first use.
+     */
+    key?: SExpr;
+    /**
+     * Source scoping (see `ListenSource`). Undefined when the listen entry is
+     * a local payload declaration rather than a bus subscription.
+     */
+    source?: ListenSource;
+};
+declare const TraitEventListenerSchema: z.ZodObject<{
+    event: z.ZodString;
+    eventId: z.ZodOptional<z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>;
+    triggers: z.ZodString;
+    triggersId: z.ZodOptional<z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>;
+    description: z.ZodOptional<z.ZodString>;
+    synonyms: z.ZodOptional<z.ZodString>;
+    tier: z.ZodOptional<z.ZodString>;
+    guard: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+    scope: z.ZodOptional<z.ZodEnum<{
+        external: "external";
+        internal: "internal";
+    }>>;
+    payloadMapping: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>>;
+    key: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+    source: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodLiteral<"any">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"trait">;
+        trait: z.ZodString;
+        traitId: z.ZodOptional<z.ZodString & z.ZodType<TraitId, string, z.core.$ZodTypeInternals<TraitId, string>>>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"orbital">;
+        orbital: z.ZodString;
+        trait: z.ZodString;
+        orbitalId: z.ZodOptional<z.ZodString & z.ZodType<OrbitalId, string, z.core.$ZodTypeInternals<OrbitalId, string>>>;
+        traitId: z.ZodOptional<z.ZodString & z.ZodType<TraitId, string, z.core.$ZodTypeInternals<TraitId, string>>>;
+    }, z.core.$strip>]>>;
+}, z.core.$strip>;
+/**
+ * Field required by a trait from its linkedEntity
+ */
+type RequiredField = {
+    name: string;
+    type: TraitFieldType;
+    description?: string;
+};
+declare const RequiredFieldSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodUnion<readonly [z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        object: "object";
+        date: "date";
+        array: "array";
+        tuple: "tuple";
+        union: "union";
+        enum: "enum";
+        pattern: "pattern";
+        trait: "trait";
+        event: "event";
+        node: "node";
+        url: "url";
+        field: "field";
+        timestamp: "timestamp";
+        image: "image";
+        slot: "slot";
+        datetime: "datetime";
+        instant: "instant";
+        email: "email";
+        phone: "phone";
+        uuid: "uuid";
+        bytes: "bytes";
+        EventAddress: "EventAddress";
+        CallKey: "CallKey";
+        SExpr: "SExpr";
+    }>, z.ZodCustom<`$${string}`, `$${string}`>]>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Reference to a trait from an entity or page.
+ *
+ * Phase F treats a trait reference as a function call: `ref` names the
+ * imported trait and the sibling fields are arguments. The compiler's
+ * identifier-substitution pass uses these arguments to rewrite the
+ * inlined trait clone before lowering.
+ */
+type TraitReference = {
+    ref: string;
+    /** V4 dual-carry id sibling of `ref` — optional until the Phase-7 flip. */
+    refId?: TraitId;
+    /**
+     * V4 LOCAL DECLARATION id — the identity of this trait AS DECLARED in its
+     * orbital (`trait X = Alias.traits.Y` declares node X; `refId` carries
+     * Y's id). Minted by the stamp so page trait refs and `@trait.X` embeds
+     * resolve by id across `name:` renames (the composed-organism surface was
+     * the one declaration class without an id).
+     */
+    id?: TraitId;
+    /**
+     * Phase 1.2: optional registry path disambiguator. Pairs with `ref` to
+     * explicitly name which `uses` entry the alias was imported from
+     * (e.g. "std/behaviors/atoms/std-browse"). Helpful for programmatic
+     * descriptor construction and inline-phase disambiguation when multiple
+     * registries expose the same alias prefix.
+     */
+    from?: string;
+    linkedEntity?: string;
+    /** V4 dual-carry id sibling of `linkedEntity` — optional until the Phase-7 flip. */
+    linkedEntityId?: EntityId;
+    /** Phase F: rename the inlined trait at the call site */
+    name?: string;
+    /** Phase F: rename atom event keys at the call site, e.g. {OPEN: "ADD_ITEM"} */
+    events?: Record<string, string>;
+    /**
+     * 3-II trait type-parameter arguments (`:: p SomeType` in `.lolo`):
+     * declared-param name → type-vocabulary name (an entity, a primitive incl.
+     * `scalar`, or a struct alias from the AUTHORING file's `types` map).
+     * Present on pre-inline registry references only — the inline phase
+     * consumes it while resolving `$<name>` payload sentinels and it never
+     * appears in a final composed `.orb`.
+     */
+    typeArgs?: Record<string, string>;
+    /** Preprocess-output carrier: the fully resolved trait this reference stands
+     *  for (`@almadar/runtime` `preprocessSchema` output only; never in a `.orb`). */
+    _resolved?: Trait;
+    /** V4 dual-carry id sibling of `events` (keys = baked event names resolved to ids) — optional until the Phase-7 flip. */
+    eventIds?: Record<string, EventId>;
+    /**
+     * Entity-field remap: rewrite the inlined trait's canonical `@entity.X` /
+     * `@payload.row.X` field references to the consumer entity's field names,
+     * e.g. `{ name: "title", folder: "parentId" }`. Mirrors `events` for
+     * fields. Applied during inline substitution alongside `linkedEntity`.
+     */
+    fields?: Record<string, string>;
+    /**
+     * Call-site config overrides. Each entry is either a plain wiring value
+     * (`TraitConfigValue`) or a fully-annotated re-declaration
+     * (`ConfigFieldDeclaration` with `type`, optional `label`/`description`/
+     * `synonyms`/`tier`). Use `isCallSiteConfigDeclaration` to discriminate.
+     *
+     * Plain wiring (existing callers): `config: { icon: "star", count: 5 }`.
+     * Annotated (new): `config: { icon: { type: "string", default: "star",
+     *   label: "Icon", tier: "presentation" } }`.
+     */
+    config?: CallSiteConfig;
+    appliesTo?: string[];
+    /**
+     * Phase F.7: replace the imported trait's `listens` array with the
+     * caller-supplied list. Empty array clears all upstream listens. The
+     * inliner applies this AFTER substitution, overwriting whatever the
+     * upstream declared. Use sparingly: this drops external event wiring.
+     */
+    listens?: TraitEventListener[];
+    /**
+     * Phase F.7: set every emit's `scope` to the caller-supplied value.
+     * `'internal'` confines emits to the orbital's internal bus; `'external'`
+     * broadcasts them. Applied after substitution and listens replacement.
+     */
+    emitsScope?: 'internal' | 'external';
+    /**
+     * Phase F.8: per-transition effects override. The map's keys are event
+     * names (the transition triggers, AFTER any rename via `events`). The
+     * values are the SExpression effect lists that REPLACE the matching
+     * transitions' `effects[]` arrays.
+     *
+     * This is the unified content + effect override mechanism. Whether the
+     * override list contains `["render-ui", ...]` (visual content),
+     * `["fetch", ...]` (data load), `["persist", ...]` (mutation), or any
+     * combination, the inliner just substitutes the whole list. Identifier
+     * substitution (entity refs, event refs) still runs over the merged
+     * trait body, so override effects can use either upstream or caller
+     * identifiers and the F.3 walker will rewrite them consistently.
+     *
+     * Example:
+     * ```json
+     * "effects": {
+     *   "ADD_ITEM": [
+     *     ["fetch", "CartItem"],
+     *     ["render-ui", "main", { ... }]
+     *   ],
+     *   "SAVE": [
+     *     ["persist", "create", "CartItem", "@payload.data"]
+     *   ]
+     * }
+     * ```
+     */
+    effects?: Record<string, SExpr[]>;
+};
+declare const TraitReferenceSchema: z.ZodObject<{
+    ref: z.ZodString;
+    refId: z.ZodOptional<z.ZodString & z.ZodType<TraitId, string, z.core.$ZodTypeInternals<TraitId, string>>>;
+    id: z.ZodOptional<z.ZodString & z.ZodType<TraitId, string, z.core.$ZodTypeInternals<TraitId, string>>>;
+    from: z.ZodOptional<z.ZodString>;
+    linkedEntity: z.ZodOptional<z.ZodString>;
+    linkedEntityId: z.ZodOptional<z.ZodString & z.ZodType<EntityId, string, z.core.$ZodTypeInternals<EntityId, string>>>;
+    name: z.ZodOptional<z.ZodString>;
+    events: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    eventIds: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>>;
+    _resolved: z.ZodOptional<z.ZodLazy<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString & z.ZodType<TraitId, string, z.core.$ZodTypeInternals<TraitId, string>>>;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        description_visual_prompt: z.ZodOptional<z.ZodString>;
+        entityRebindable: z.ZodOptional<z.ZodBoolean>;
+        entityContract: z.ZodOptional<z.ZodObject<{
+            requires: z.ZodArray<z.ZodString>;
+            provides: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+        effectRow: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            kind: z.ZodString;
+            resource: z.ZodOptional<z.ZodString>;
+            resolved: z.ZodOptional<z.ZodBoolean>;
+            site: z.ZodOptional<z.ZodEnum<{
+                transition: "transition";
+                tick: "tick";
+            }>>;
+        }, z.core.$strip>>>;
+        entityBindingDescription: z.ZodOptional<z.ZodString>;
+        entityBindingSynonyms: z.ZodOptional<z.ZodString>;
+        dispatch: z.ZodOptional<z.ZodEnum<{
+            client: "client";
+            optimistic: "optimistic";
+            server: "server";
+        }>>;
+        linkedEntity: z.ZodOptional<z.ZodString>;
+        linkedEntityId: z.ZodOptional<z.ZodString & z.ZodType<EntityId, string, z.core.$ZodTypeInternals<EntityId, string>>>;
+        entityRefIds: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString & z.ZodType<EntityId, string, z.core.$ZodTypeInternals<EntityId, string>>>>;
+        traitEmbedIds: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString & z.ZodType<TraitId, string, z.core.$ZodTypeInternals<TraitId, string>>>>;
+        requiredFields: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodUnion<readonly [z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                object: "object";
+                date: "date";
+                array: "array";
+                tuple: "tuple";
+                union: "union";
+                enum: "enum";
+                pattern: "pattern";
+                trait: "trait";
+                event: "event";
+                node: "node";
+                url: "url";
+                field: "field";
+                timestamp: "timestamp";
+                image: "image";
+                slot: "slot";
+                datetime: "datetime";
+                instant: "instant";
+                email: "email";
+                phone: "phone";
+                uuid: "uuid";
+                bytes: "bytes";
+                EventAddress: "EventAddress";
+                CallKey: "CallKey";
+                SExpr: "SExpr";
+            }>, z.ZodCustom<`$${string}`, `$${string}`>]>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        dataEntities: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            collection: z.ZodOptional<z.ZodString>;
+            fields: z.ZodArray<z.ZodType<TraitEntityField, object, z.core.$ZodTypeInternals<TraitEntityField, object>>>;
+            timestamps: z.ZodOptional<z.ZodBoolean>;
+            description: z.ZodOptional<z.ZodString>;
+            runtime: z.ZodOptional<z.ZodBoolean>;
+            singleton: z.ZodOptional<z.ZodBoolean>;
+            pages: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>;
+        stateMachine: z.ZodOptional<z.ZodObject<{
+            states: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                isInitial: z.ZodOptional<z.ZodBoolean>;
+                isTerminal: z.ZodOptional<z.ZodBoolean>;
+                isFinal: z.ZodOptional<z.ZodBoolean>;
+                description: z.ZodOptional<z.ZodString>;
+                onEntry: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                onExit: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                holds: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+            }, z.core.$strip>>;
+            events: z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                id: z.ZodOptional<z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>;
+                name: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                synonyms: z.ZodOptional<z.ZodString>;
+                tier: z.ZodOptional<z.ZodString>;
+                payloadSchema: z.ZodOptional<z.ZodArray<z.ZodType<PayloadField, unknown, z.core.$ZodTypeInternals<PayloadField, unknown>>>>;
+                payloadEntity: z.ZodOptional<z.ZodString>;
+                input: z.ZodOptional<z.ZodBoolean>;
+                listened: z.ZodOptional<z.ZodBoolean>;
+                inbound: z.ZodOptional<z.ZodObject<{
+                    name: z.ZodString;
+                    answers: z.ZodString;
+                    verifies: z.ZodOptional<z.ZodObject<{
+                        header: z.ZodString;
+                        credential: z.ZodString;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
+                classification: z.ZodOptional<z.ZodEnum<{
+                    domain: "domain";
+                    system: "system";
+                }>>;
+                semanticRole: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            transitions: z.ZodArray<z.ZodObject<{
+                from: z.ZodString;
+                to: z.ZodString;
+                event: z.ZodString;
+                eventId: z.ZodOptional<z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>;
+                guard: z.ZodOptional<z.ZodNullable<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>>;
+                effects: z.ZodOptional<z.ZodArray<z.ZodType<TypedEffect, unknown, z.core.$ZodTypeInternals<TypedEffect, unknown>>>>;
+                ensures: z.ZodOptional<z.ZodType<SExpr[], unknown, z.core.$ZodTypeInternals<SExpr[], unknown>>>;
+                description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                awaitRender: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    trait: z.ZodString;
+                    slot: z.ZodString;
+                    skeleton: z.ZodType<SkeletonNode, unknown, z.core.$ZodTypeInternals<SkeletonNode, unknown>>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>>;
+            guards: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                expression: z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+        initialEffects: z.ZodOptional<z.ZodArray<z.ZodType<TypedEffect, unknown, z.core.$ZodTypeInternals<TypedEffect, unknown>>>>;
+        ticks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            priority: z.ZodOptional<z.ZodNumber>;
+            interval: z.ZodUnion<readonly [z.ZodLiteral<"frame">, z.ZodNumber, z.ZodString]>;
+            appliesTo: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            runsInBackground: z.ZodOptional<z.ZodBoolean>;
+            whileVisible: z.ZodOptional<z.ZodBoolean>;
+            pages: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            pageIds: z.ZodOptional<z.ZodArray<z.ZodString & z.ZodType<PageId, string, z.core.$ZodTypeInternals<PageId, string>>>>;
+            guard: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+            effects: z.ZodArray<z.ZodType<TypedEffect, unknown, z.core.$ZodTypeInternals<TypedEffect, unknown>>>;
+            emits: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            emitIds: z.ZodOptional<z.ZodArray<z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>>;
+        }, z.core.$strip>>>;
+        emits: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            event: z.ZodString;
+            eventId: z.ZodOptional<z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>;
+            description: z.ZodOptional<z.ZodString>;
+            synonyms: z.ZodOptional<z.ZodString>;
+            tier: z.ZodOptional<z.ZodString>;
+            definerKnob: z.ZodOptional<z.ZodString>;
+            scopeOverridden: z.ZodOptional<z.ZodBoolean>;
+            payloadSchema: z.ZodOptional<z.ZodArray<z.ZodType<PayloadField, unknown, z.core.$ZodTypeInternals<PayloadField, unknown>>>>;
+            payloadEntity: z.ZodOptional<z.ZodString>;
+            scope: z.ZodOptional<z.ZodEnum<{
+                external: "external";
+                internal: "internal";
+            }>>;
+        }, z.core.$strip>>>;
+        listens: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            event: z.ZodString;
+            eventId: z.ZodOptional<z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>;
+            triggers: z.ZodString;
+            triggersId: z.ZodOptional<z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>;
+            description: z.ZodOptional<z.ZodString>;
+            synonyms: z.ZodOptional<z.ZodString>;
+            tier: z.ZodOptional<z.ZodString>;
+            guard: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+            scope: z.ZodOptional<z.ZodEnum<{
+                external: "external";
+                internal: "internal";
+            }>>;
+            payloadMapping: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>>;
+            key: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+            source: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                kind: z.ZodLiteral<"any">;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"trait">;
+                trait: z.ZodString;
+                traitId: z.ZodOptional<z.ZodString & z.ZodType<TraitId, string, z.core.$ZodTypeInternals<TraitId, string>>>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"orbital">;
+                orbital: z.ZodString;
+                trait: z.ZodString;
+                orbitalId: z.ZodOptional<z.ZodString & z.ZodType<OrbitalId, string, z.core.$ZodTypeInternals<OrbitalId, string>>>;
+                traitId: z.ZodOptional<z.ZodString & z.ZodType<TraitId, string, z.core.$ZodTypeInternals<TraitId, string>>>;
+            }, z.core.$strip>]>>;
+        }, z.core.$strip>>>;
+        events: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        ui: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            presentation: z.ZodEnum<{
+                modal: "modal";
+                drawer: "drawer";
+                "confirm-dialog": "confirm-dialog";
+                popover: "popover";
+                inline: "inline";
+            }>;
+            content: z.ZodUnion<readonly [z.ZodType<AnyPatternConfig, unknown, z.core.$ZodTypeInternals<AnyPatternConfig, unknown>>, z.ZodArray<z.ZodType<AnyPatternConfig, unknown, z.core.$ZodTypeInternals<AnyPatternConfig, unknown>>>]>;
+            props: z.ZodOptional<z.ZodObject<{
+                size: z.ZodOptional<z.ZodEnum<{
+                    md: "md";
+                    sm: "sm";
+                    full: "full";
+                    lg: "lg";
+                    xl: "xl";
+                }>>;
+                position: z.ZodOptional<z.ZodEnum<{
+                    right: "right";
+                    center: "center";
+                    top: "top";
+                    bottom: "bottom";
+                    left: "left";
+                }>>;
+                title: z.ZodOptional<z.ZodString>;
+                closable: z.ZodOptional<z.ZodBoolean>;
+                width: z.ZodOptional<z.ZodString>;
+                showProgress: z.ZodOptional<z.ZodBoolean>;
+                step: z.ZodOptional<z.ZodNumber>;
+                totalSteps: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+        config: z.ZodOptional<z.ZodType<Readonly<Record<string, ConfigFieldDeclaration>>, Record<string, object>, z.core.$ZodTypeInternals<Readonly<Record<string, ConfigFieldDeclaration>>, Record<string, object>>>>;
+        sourceBehavior: z.ZodOptional<z.ZodObject<{
+            behavior: z.ZodString;
+            alias: z.ZodString;
+            originalName: z.ZodString;
+        }, z.core.$strip>>;
+        sourceDeclaration: z.ZodOptional<z.ZodObject<{
+            traitId: z.ZodString;
+            fingerprint: z.ZodString;
+        }, z.core.$strip>>;
+        sourceEntityDefinition: z.ZodOptional<z.ZodObject<{
+            name: z.ZodString;
+            id: z.ZodOptional<z.ZodString & z.ZodType<EntityId, string, z.core.$ZodTypeInternals<EntityId, string>>>;
+            persistence: z.ZodDefault<z.ZodEnum<{
+                persistent: "persistent";
+                runtime: "runtime";
+            }>>;
+            shared: z.ZodOptional<z.ZodBoolean>;
+            identity: z.ZodOptional<z.ZodBoolean>;
+            browser: z.ZodOptional<z.ZodBoolean>;
+            store: z.ZodOptional<z.ZodString>;
+            read_policy: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+            create_policy: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+            update_policy: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+            delete_policy: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+            access_waivers: z.ZodOptional<z.ZodObject<{
+                read: z.ZodOptional<z.ZodString>;
+                create: z.ZodOptional<z.ZodString>;
+                update: z.ZodOptional<z.ZodString>;
+                delete: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            invariants: z.ZodOptional<z.ZodType<SExpr[], unknown, z.core.$ZodTypeInternals<SExpr[], unknown>>>;
+            indexes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                fields: z.ZodArray<z.ZodString>;
+                orderBy: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            collection: z.ZodOptional<z.ZodString>;
+            fields: z.ZodArray<z.ZodType<EntityField, unknown, z.core.$ZodTypeInternals<EntityField, unknown>>>;
+            instances: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>>;
+            localeInstances: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>>>;
+            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>>;
+                style: z.ZodOptional<z.ZodEnum<{
+                    isometric: "isometric";
+                    pixel: "pixel";
+                    vector: "vector";
+                    hd: "hd";
+                    "1-bit": "1-bit";
+                }>>;
+                variant: z.ZodOptional<z.ZodString>;
+                dimension: z.ZodOptional<z.ZodEnum<{
+                    "2d": "2d";
+                    "3d": "3d";
+                }>>;
+                aspect: z.ZodOptional<z.ZodEnum<{
+                    "1:1": "1:1";
+                    "16:9": "16:9";
+                    "5:7": "5:7";
+                    "8:1": "8:1";
+                    "4:1": "4:1";
+                    "5:3": "5:3";
+                    "1:2": "1:2";
+                }>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        typeParams: z.ZodOptional<z.ZodArray<z.ZodType<TraitTypeParamDef, unknown, z.core.$ZodTypeInternals<TraitTypeParamDef, unknown>>>>;
+    }, z.core.$strip>>>;
+    typeArgs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodType<ConfigFieldDeclaration, object, z.core.$ZodTypeInternals<ConfigFieldDeclaration, object>>, z.ZodType<TraitConfigValue, unknown, z.core.$ZodTypeInternals<TraitConfigValue, unknown>>]>>>;
+    appliesTo: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    listens: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        event: z.ZodString;
+        eventId: z.ZodOptional<z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>;
+        triggers: z.ZodString;
+        triggersId: z.ZodOptional<z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>;
+        description: z.ZodOptional<z.ZodString>;
+        synonyms: z.ZodOptional<z.ZodString>;
+        tier: z.ZodOptional<z.ZodString>;
+        guard: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+        scope: z.ZodOptional<z.ZodEnum<{
+            external: "external";
+            internal: "internal";
+        }>>;
+        payloadMapping: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>>;
+        key: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+        source: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            kind: z.ZodLiteral<"any">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"trait">;
+            trait: z.ZodString;
+            traitId: z.ZodOptional<z.ZodString & z.ZodType<TraitId, string, z.core.$ZodTypeInternals<TraitId, string>>>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"orbital">;
+            orbital: z.ZodString;
+            trait: z.ZodString;
+            orbitalId: z.ZodOptional<z.ZodString & z.ZodType<OrbitalId, string, z.core.$ZodTypeInternals<OrbitalId, string>>>;
+            traitId: z.ZodOptional<z.ZodString & z.ZodType<TraitId, string, z.core.$ZodTypeInternals<TraitId, string>>>;
+        }, z.core.$strip>]>>;
+    }, z.core.$strip>>>;
+    emitsScope: z.ZodOptional<z.ZodEnum<{
+        external: "external";
+        internal: "internal";
+    }>>;
+    effects: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>>>;
+}, z.core.$strip>;
+/**
+ * Simplified trait reference - supports string, reference object, or inline Trait definition
+ * - string: "TraitName" - reference to a trait by name
+ * - { ref: "TraitName" }: reference object with optional config / overrides
+ * - { name: "TraitName", stateMachine: {...} }: inline trait definition
+ *
+ * Phase F adds `name` and `events` to the reference object form so callers
+ * can rename the trait and remap atom event keys.
+ */
+/** A trait in an orbital: a bare name, a reference (the full `TraitReference` the wire carries), or an inline trait. */
+type TraitRef = string | TraitReference | Trait;
+type PresentationType = 'modal' | 'drawer' | 'popover' | 'inline' | 'confirm-dialog';
+type TraitUIBinding = {
+    [stateName: string]: {
+        presentation: PresentationType;
+        content: AnyPatternConfig | AnyPatternConfig[];
+        props?: {
+            size?: 'sm' | 'md' | 'lg' | 'xl' | 'full';
+            position?: 'left' | 'right' | 'top' | 'bottom' | 'center';
+            title?: string;
+            closable?: boolean;
+            width?: string;
+            showProgress?: boolean;
+            step?: number;
+            totalSteps?: number;
+        };
+    };
+};
+/**
+ * Zod schema for {@link TraitUIBinding}. `content` is a pattern config (or
+ * list of them), validated as pattern objects by {@link PatternObjectSchema}
+ * (the registry checks props at validate time).
+ */
+declare const TraitUIBindingSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    presentation: z.ZodEnum<{
+        modal: "modal";
+        drawer: "drawer";
+        "confirm-dialog": "confirm-dialog";
+        popover: "popover";
+        inline: "inline";
+    }>;
+    content: z.ZodUnion<readonly [z.ZodType<AnyPatternConfig, unknown, z.core.$ZodTypeInternals<AnyPatternConfig, unknown>>, z.ZodArray<z.ZodType<AnyPatternConfig, unknown, z.core.$ZodTypeInternals<AnyPatternConfig, unknown>>>]>;
+    props: z.ZodOptional<z.ZodObject<{
+        size: z.ZodOptional<z.ZodEnum<{
+            md: "md";
+            sm: "sm";
+            full: "full";
+            lg: "lg";
+            xl: "xl";
+        }>>;
+        position: z.ZodOptional<z.ZodEnum<{
+            right: "right";
+            center: "center";
+            top: "top";
+            bottom: "bottom";
+            left: "left";
+        }>>;
+        title: z.ZodOptional<z.ZodString>;
+        closable: z.ZodOptional<z.ZodBoolean>;
+        width: z.ZodOptional<z.ZodString>;
+        showProgress: z.ZodOptional<z.ZodBoolean>;
+        step: z.ZodOptional<z.ZodNumber>;
+        totalSteps: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>>;
+/**
+ * A Trait is a reusable behavioral module with state machine.
+ *
+ * Traits declare their event contracts via `emits` and `listens`:
+ * - `emits`: Events this trait can emit (with scope and payload schema)
+ * - `listens`: Events this trait listens for (with optional payloadMapping)
+ */
+/**
+ * Inferred field contract for a `@rebindable` trait binding. `requires` =
+ * entity fields the trait READS via `@entity.<field>`; `provides` = fields it
+ * WRITES via `(set @entity.<field> ...)`. A consumer that rebinds the trait
+ * (`linkedEntity`) must point at an entity whose fields ⊇ `requires`. Inferred
+ * by the lolo lowerer from the trait's own SExpr usage; the orbital-rust L2
+ * validator enforces it (`ORB_T_REBIND_MISSING_FIELDS`). Mirrors the Rust
+ * `EntityFieldContract` serde shape exactly.
+ */
+type EntityFieldContract = {
+    requires: string[];
+    provides: string[];
+};
+declare const EntityFieldContractSchema: z.ZodObject<{
+    requires: z.ZodArray<z.ZodString>;
+    provides: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Where in a trait an effect is declared. The distinction is load-bearing: a
+ * `render-ui` in a transition fires when that transition fires, but one inside a
+ * `ticks` block repaints every frame, so two tick writers on one slot paint
+ * together where two transition writers routinely alternate.
+ */
+type EffectSite = 'transition' | 'tick';
+/**
+ * One effect a trait produces, with the resource it acts on — the slot for
+ * `render-ui`, the entity for `persist`/`fetch`, the event for `emit`, the
+ * binding path for `set`. `resource` is recorded verbatim as authored; when the
+ * author deferred it to a call site (`@config.surface`) the reference is kept as
+ * written and `resolved` is false. Mirrors the Rust `EffectUse` serde shape.
+ */
+type EffectUse = {
+    kind: string;
+    resource?: string;
+    /** Absent means true — only an unresolved `@config.*` resource sets it. */
+    resolved?: boolean;
+    /** Absent means `'transition'`. */
+    site?: EffectSite;
+};
+/**
+ * Every effect a trait produces — what composing it actually brings along.
+ *
+ * Inferred by the lolo lowerer from the trait's own effects (never authored, the
+ * way {@link EntityFieldContract} is never authored), then re-derived
+ * post-inline once call-site config makes `@config.*` resources concrete. A
+ * trait's type used to say nothing about its effects, which is why "is this safe
+ * to compose?" could only be answered by reading the atom.
+ */
+type EffectRow = EffectUse[];
+/**
+ * Client dispatch strategy for a trait's transitions — the ONE rule,
+ * computed from declared facts only, never inferred from a trait's effects
+ * (`docs/Almadar_LOLO.md` §7). Mirrors `orbital-core`'s
+ * `runtime::dispatch_mode::DispatchMode` serde shape exactly (the enum both
+ * `OirTrait::dispatch_mode` (compiled path) and `TraitDefinition::dispatch_mode`
+ * (runtime kernel) return) — same variant spellings, so a value round-trips
+ * on the wire unchanged.
+ */
+type DispatchMode = 'persistedAwaited' | 'hybridClientOnly' | 'runtimeOptimistic';
+declare const DispatchModeSchema: z.ZodEnum<{
+    persistedAwaited: "persistedAwaited";
+    hybridClientOnly: "hybridClientOnly";
+    runtimeOptimistic: "runtimeOptimistic";
+}>;
+/** The `[client]` / `[optimistic]` / `[server]` trait-header word; absent = server dispatch, `server` is the explicit spelling that overrides an atom's mode. Mirrors Rust `DispatchMode` (serde lowercase). */
+type TraitDispatchMode = 'client' | 'optimistic' | 'server';
+declare const TraitDispatchModeSchema: z.ZodEnum<{
+    client: "client";
+    optimistic: "optimistic";
+    server: "server";
+}>;
+type Trait = {
+    /** V4 dual-carry id sibling of `name` — optional until the Phase-7 flip. */
+    id?: TraitId;
+    name: string;
+    description?: string;
+    description_visual_prompt?: string;
+    /**
+     * Opt-in marker authored as `-> @rebindable Entity` in `.lolo`. When
+     * `true`, a consuming molecule/organism may rebind this trait's entity via
+     * `linkedEntity`; otherwise the binding is fixed and the validator rejects
+     * any rebind (`ORB_T_ENTITY_NOT_REBINDABLE`). Absent on traits that don't
+     * bind an entity.
+     */
+    entityRebindable?: boolean;
+    /**
+     * Inferred field contract a rebind target must satisfy. Emitted only
+     * alongside `entityRebindable: true`. See {@link EntityFieldContract}.
+     */
+    entityContract?: EntityFieldContract;
+    /**
+     * Inferred effect surface. Absent on traits that produce no effects at all.
+     * See {@link EffectRow}.
+     */
+    effectRow?: EffectRow;
+    /**
+     * `@description "..."` authored on the `@rebindable` binding in `.lolo`.
+     * Surfaced to catalog prose + knob-embeddings so the LLM can reach for the
+     * binding from intent vocabulary (binding-discovery). Absent when unmarked.
+     */
+    entityBindingDescription?: string;
+    /** `@synonyms "..."` authored on the `@rebindable` binding in `.lolo`. */
+    entityBindingSynonyms?: string;
+    /**
+     * Dispatch mode authored as `[client]` / `[optimistic]` / `[server]` on the `.lolo` trait
+     * header. Absent means server dispatch. Mirrors the Rust
+     * `TraitDefinition.dispatch` field; never inferred from effects.
+     */
+    dispatch?: TraitDispatchMode;
+    /**
+     * The entity this trait is linked to.
+     * Required for inline trait definitions within an orbital.
+     */
+    linkedEntity?: string;
+    /** V4 dual-carry id sibling of `linkedEntity` — optional until the Phase-7 flip. */
+    linkedEntityId?: EntityId;
+    /**
+     * V4 leverage-ids — id side-map for `@entity.<Name>` binding tokens + positional
+     * entity args (`fetch`/`ref`/`persist`/`spawn`) in this trait's guards/effects/
+     * ticks/listens. Maps the referenced entity NAME → its stable id, so readers
+     * resolve these bare-string positions by id (else name) and an entity rename never
+     * strands them — the coverage that lets the entity name-rewriter be deleted.
+     */
+    entityRefIds?: Record<string, EntityId>;
+    /**
+     * V4 leverage-ids — id side-map for `@trait.<Name>` embed tokens (render-ui embeds /
+     * effect-tree sibling refs). Maps the embed token NAME → the embedded trait's stable
+     * id, so readers splice embeds by id (else name) — the coverage that lets the
+     * `@trait.` name-rewriter be deleted.
+     */
+    traitEmbedIds?: Record<string, TraitId>;
+    requiredFields?: RequiredField[];
+    dataEntities?: TraitDataEntity[];
+    stateMachine?: StateMachine;
+    initialEffects?: Effect[];
+    ticks?: TraitTick[];
+    /**
+     * Events this trait emits.
+     * Each event can be scoped as internal or external.
+     * External events are namespaced at orbital level (TraitName.EVENT_NAME).
+     */
+    emits?: TraitEventContract[];
+    /**
+     * Events this trait listens for.
+     * External listeners reference namespaced events (TraitName.EVENT_NAME).
+     */
+    listens?: TraitEventListener[];
+    /**
+     * `events { ACTION: CONFIRM_VOID }` — the call-site rename map that binds a
+     * pattern's own event slot (the key, e.g. a Button's `ACTION`) to the app
+     * event it fires (the value). Emitted into the IR by the inliner and read
+     * by wiring analysis: without it, an affordance whose event lives here
+     * rather than in the render payload looks like it fires nothing.
+     */
+    events?: Readonly<Record<string, string>>;
+    ui?: TraitUIBinding;
+    /**
+     * Declared `config { }` schema authored on the trait. Drives
+     * `@config.X` substitution: each field's `default` seeds the
+     * binding context behind any caller-supplied call-site
+     * `config: { ... }` override.
+     */
+    config?: DeclaredTraitConfig;
+    /**
+     * Set by the resolve/inline phase when this trait was cloned from a
+     * `uses[]` import. Absent for traits authored directly on the
+     * orbital. Viewport-only metadata — runtime and codegen ignore it.
+     * Drives Studio's L2 grouping (imported traits collapse under one
+     * card per alias) and L3 drill (alias → that behavior's transitions).
+     */
+    sourceBehavior?: SourceBehaviorMetadata;
+    sourceDeclaration?: SourceDeclarationMetadata;
+    /**
+     * Set by the resolve/inline phase alongside `sourceBehavior`. Carries
+     * the resolved `Entity` definition of the imported behavior so the
+     * client-side mock-data generator can produce rows for the trait's
+     * `linkedEntity` without re-walking the import graph at runtime.
+     */
+    sourceEntityDefinition?: Entity;
+    /**
+     * Increment 3-II: this trait's own declared type parameters. Present
+     * only on an atom's DECLARING inline trait (never authored on a
+     * reference); survives cloning into a consumer's composed schema.
+     */
+    typeParams?: TraitTypeParamDef[];
+};
+/**
+ * Provenance attached to a trait that was cloned from a `uses[]` import
+ * during the inline phase. The resolved schema carries this so Studio
+ * can group L2 cards by source behavior and offer an L3 drill into the
+ * import's own transitions.
+ */
+type SourceBehaviorMetadata = {
+    /** Behavior name (e.g. "std-stat-card") — the resolved `from:` value. */
+    behavior: string;
+    /** Alias used at the import site (e.g. "Stat"). Multiple imports of
+     *  the same atom group by alias, not by behavior. */
+    alias: string;
+    /** Original trait name inside the imported behavior, before any
+     *  call-site `name:` rename. */
+    originalName: string;
+};
+type SourceDeclarationMetadata = {
+    traitId: string;
+    fingerprint: string;
+};
+/**
+ * One trait-level type parameter — `(V : Type, R : Type)` in
+ * `trait Name (V : Type, R : Type) -> Entity { ... }`. Present only on an
+ * atom's DECLARING inline trait; survives cloning into a consumer's composed
+ * schema so the inline phase can read each param's `kind` when resolving a
+ * surviving `"$<name>"` payload sentinel. `kind` is one of the six alias
+ * type-parameter kind names (`Type`, `Entity`, `Trait`, `Page`, `Orbital`,
+ * `Event`) — in practice `Type` and `Entity` are the two meaningful kinds
+ * for a trait param today.
+ */
+type TraitTypeParamDef = {
+    name: string;
+    kind: string;
+    /**
+     * Declaration default (`(r : Type = <name>)`) — a primitive name (incl.
+     * `scalar`), an entity name, or a struct-alias name, all resolved in
+     * the atom's own file. Consulted only when no call-site `::` arg was
+     * supplied (and, for Entity-kind, only when `linkedEntity` also gave no
+     * default).
+     */
+    default?: string;
+};
+declare const TraitSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString & z.ZodType<TraitId, string, z.core.$ZodTypeInternals<TraitId, string>>>;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    description_visual_prompt: z.ZodOptional<z.ZodString>;
+    entityRebindable: z.ZodOptional<z.ZodBoolean>;
+    entityContract: z.ZodOptional<z.ZodObject<{
+        requires: z.ZodArray<z.ZodString>;
+        provides: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    effectRow: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        kind: z.ZodString;
+        resource: z.ZodOptional<z.ZodString>;
+        resolved: z.ZodOptional<z.ZodBoolean>;
+        site: z.ZodOptional<z.ZodEnum<{
+            transition: "transition";
+            tick: "tick";
+        }>>;
+    }, z.core.$strip>>>;
+    entityBindingDescription: z.ZodOptional<z.ZodString>;
+    entityBindingSynonyms: z.ZodOptional<z.ZodString>;
+    dispatch: z.ZodOptional<z.ZodEnum<{
+        client: "client";
+        optimistic: "optimistic";
+        server: "server";
+    }>>;
+    linkedEntity: z.ZodOptional<z.ZodString>;
+    linkedEntityId: z.ZodOptional<z.ZodString & z.ZodType<EntityId, string, z.core.$ZodTypeInternals<EntityId, string>>>;
+    entityRefIds: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString & z.ZodType<EntityId, string, z.core.$ZodTypeInternals<EntityId, string>>>>;
+    traitEmbedIds: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString & z.ZodType<TraitId, string, z.core.$ZodTypeInternals<TraitId, string>>>>;
+    requiredFields: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodUnion<readonly [z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+            object: "object";
+            date: "date";
+            array: "array";
+            tuple: "tuple";
+            union: "union";
+            enum: "enum";
+            pattern: "pattern";
+            trait: "trait";
+            event: "event";
+            node: "node";
+            url: "url";
+            field: "field";
+            timestamp: "timestamp";
+            image: "image";
+            slot: "slot";
+            datetime: "datetime";
+            instant: "instant";
+            email: "email";
+            phone: "phone";
+            uuid: "uuid";
+            bytes: "bytes";
+            EventAddress: "EventAddress";
+            CallKey: "CallKey";
+            SExpr: "SExpr";
+        }>, z.ZodCustom<`$${string}`, `$${string}`>]>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    dataEntities: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        collection: z.ZodOptional<z.ZodString>;
+        fields: z.ZodArray<z.ZodType<TraitEntityField, object, z.core.$ZodTypeInternals<TraitEntityField, object>>>;
+        timestamps: z.ZodOptional<z.ZodBoolean>;
+        description: z.ZodOptional<z.ZodString>;
+        runtime: z.ZodOptional<z.ZodBoolean>;
+        singleton: z.ZodOptional<z.ZodBoolean>;
+        pages: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    stateMachine: z.ZodOptional<z.ZodObject<{
+        states: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            isInitial: z.ZodOptional<z.ZodBoolean>;
+            isTerminal: z.ZodOptional<z.ZodBoolean>;
+            isFinal: z.ZodOptional<z.ZodBoolean>;
+            description: z.ZodOptional<z.ZodString>;
+            onEntry: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            onExit: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            holds: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+        }, z.core.$strip>>;
+        events: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            id: z.ZodOptional<z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>;
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            synonyms: z.ZodOptional<z.ZodString>;
+            tier: z.ZodOptional<z.ZodString>;
+            payloadSchema: z.ZodOptional<z.ZodArray<z.ZodType<PayloadField, unknown, z.core.$ZodTypeInternals<PayloadField, unknown>>>>;
+            payloadEntity: z.ZodOptional<z.ZodString>;
+            input: z.ZodOptional<z.ZodBoolean>;
+            listened: z.ZodOptional<z.ZodBoolean>;
+            inbound: z.ZodOptional<z.ZodObject<{
+                name: z.ZodString;
+                answers: z.ZodString;
+                verifies: z.ZodOptional<z.ZodObject<{
+                    header: z.ZodString;
+                    credential: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            classification: z.ZodOptional<z.ZodEnum<{
+                domain: "domain";
+                system: "system";
+            }>>;
+            semanticRole: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        transitions: z.ZodArray<z.ZodObject<{
+            from: z.ZodString;
+            to: z.ZodString;
+            event: z.ZodString;
+            eventId: z.ZodOptional<z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>;
+            guard: z.ZodOptional<z.ZodNullable<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>>;
+            effects: z.ZodOptional<z.ZodArray<z.ZodType<TypedEffect, unknown, z.core.$ZodTypeInternals<TypedEffect, unknown>>>>;
+            ensures: z.ZodOptional<z.ZodType<SExpr[], unknown, z.core.$ZodTypeInternals<SExpr[], unknown>>>;
+            description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            awaitRender: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                trait: z.ZodString;
+                slot: z.ZodString;
+                skeleton: z.ZodType<SkeletonNode, unknown, z.core.$ZodTypeInternals<SkeletonNode, unknown>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+        guards: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            expression: z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    initialEffects: z.ZodOptional<z.ZodArray<z.ZodType<TypedEffect, unknown, z.core.$ZodTypeInternals<TypedEffect, unknown>>>>;
+    ticks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        priority: z.ZodOptional<z.ZodNumber>;
+        interval: z.ZodUnion<readonly [z.ZodLiteral<"frame">, z.ZodNumber, z.ZodString]>;
+        appliesTo: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        runsInBackground: z.ZodOptional<z.ZodBoolean>;
+        whileVisible: z.ZodOptional<z.ZodBoolean>;
+        pages: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        pageIds: z.ZodOptional<z.ZodArray<z.ZodString & z.ZodType<PageId, string, z.core.$ZodTypeInternals<PageId, string>>>>;
+        guard: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+        effects: z.ZodArray<z.ZodType<TypedEffect, unknown, z.core.$ZodTypeInternals<TypedEffect, unknown>>>;
+        emits: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        emitIds: z.ZodOptional<z.ZodArray<z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>>;
+    }, z.core.$strip>>>;
+    emits: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        event: z.ZodString;
+        eventId: z.ZodOptional<z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>;
+        description: z.ZodOptional<z.ZodString>;
+        synonyms: z.ZodOptional<z.ZodString>;
+        tier: z.ZodOptional<z.ZodString>;
+        definerKnob: z.ZodOptional<z.ZodString>;
+        scopeOverridden: z.ZodOptional<z.ZodBoolean>;
+        payloadSchema: z.ZodOptional<z.ZodArray<z.ZodType<PayloadField, unknown, z.core.$ZodTypeInternals<PayloadField, unknown>>>>;
+        payloadEntity: z.ZodOptional<z.ZodString>;
+        scope: z.ZodOptional<z.ZodEnum<{
+            external: "external";
+            internal: "internal";
+        }>>;
+    }, z.core.$strip>>>;
+    listens: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        event: z.ZodString;
+        eventId: z.ZodOptional<z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>;
+        triggers: z.ZodString;
+        triggersId: z.ZodOptional<z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>;
+        description: z.ZodOptional<z.ZodString>;
+        synonyms: z.ZodOptional<z.ZodString>;
+        tier: z.ZodOptional<z.ZodString>;
+        guard: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+        scope: z.ZodOptional<z.ZodEnum<{
+            external: "external";
+            internal: "internal";
+        }>>;
+        payloadMapping: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>>;
+        key: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+        source: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            kind: z.ZodLiteral<"any">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"trait">;
+            trait: z.ZodString;
+            traitId: z.ZodOptional<z.ZodString & z.ZodType<TraitId, string, z.core.$ZodTypeInternals<TraitId, string>>>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"orbital">;
+            orbital: z.ZodString;
+            trait: z.ZodString;
+            orbitalId: z.ZodOptional<z.ZodString & z.ZodType<OrbitalId, string, z.core.$ZodTypeInternals<OrbitalId, string>>>;
+            traitId: z.ZodOptional<z.ZodString & z.ZodType<TraitId, string, z.core.$ZodTypeInternals<TraitId, string>>>;
+        }, z.core.$strip>]>>;
+    }, z.core.$strip>>>;
+    events: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    ui: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        presentation: z.ZodEnum<{
+            modal: "modal";
+            drawer: "drawer";
+            "confirm-dialog": "confirm-dialog";
+            popover: "popover";
+            inline: "inline";
+        }>;
+        content: z.ZodUnion<readonly [z.ZodType<AnyPatternConfig, unknown, z.core.$ZodTypeInternals<AnyPatternConfig, unknown>>, z.ZodArray<z.ZodType<AnyPatternConfig, unknown, z.core.$ZodTypeInternals<AnyPatternConfig, unknown>>>]>;
+        props: z.ZodOptional<z.ZodObject<{
+            size: z.ZodOptional<z.ZodEnum<{
+                md: "md";
+                sm: "sm";
+                full: "full";
+                lg: "lg";
+                xl: "xl";
+            }>>;
+            position: z.ZodOptional<z.ZodEnum<{
+                right: "right";
+                center: "center";
+                top: "top";
+                bottom: "bottom";
+                left: "left";
+            }>>;
+            title: z.ZodOptional<z.ZodString>;
+            closable: z.ZodOptional<z.ZodBoolean>;
+            width: z.ZodOptional<z.ZodString>;
+            showProgress: z.ZodOptional<z.ZodBoolean>;
+            step: z.ZodOptional<z.ZodNumber>;
+            totalSteps: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    config: z.ZodOptional<z.ZodType<Readonly<Record<string, ConfigFieldDeclaration>>, Record<string, object>, z.core.$ZodTypeInternals<Readonly<Record<string, ConfigFieldDeclaration>>, Record<string, object>>>>;
+    sourceBehavior: z.ZodOptional<z.ZodObject<{
+        behavior: z.ZodString;
+        alias: z.ZodString;
+        originalName: z.ZodString;
+    }, z.core.$strip>>;
+    sourceDeclaration: z.ZodOptional<z.ZodObject<{
+        traitId: z.ZodString;
+        fingerprint: z.ZodString;
+    }, z.core.$strip>>;
+    sourceEntityDefinition: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        id: z.ZodOptional<z.ZodString & z.ZodType<EntityId, string, z.core.$ZodTypeInternals<EntityId, string>>>;
+        persistence: z.ZodDefault<z.ZodEnum<{
+            persistent: "persistent";
+            runtime: "runtime";
+        }>>;
+        shared: z.ZodOptional<z.ZodBoolean>;
+        identity: z.ZodOptional<z.ZodBoolean>;
+        browser: z.ZodOptional<z.ZodBoolean>;
+        store: z.ZodOptional<z.ZodString>;
+        read_policy: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+        create_policy: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+        update_policy: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+        delete_policy: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+        access_waivers: z.ZodOptional<z.ZodObject<{
+            read: z.ZodOptional<z.ZodString>;
+            create: z.ZodOptional<z.ZodString>;
+            update: z.ZodOptional<z.ZodString>;
+            delete: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        invariants: z.ZodOptional<z.ZodType<SExpr[], unknown, z.core.$ZodTypeInternals<SExpr[], unknown>>>;
+        indexes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            fields: z.ZodArray<z.ZodString>;
+            orderBy: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        collection: z.ZodOptional<z.ZodString>;
+        fields: z.ZodArray<z.ZodType<EntityField, unknown, z.core.$ZodTypeInternals<EntityField, unknown>>>;
+        instances: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>>;
+        localeInstances: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>>>;
+        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>>;
+            style: z.ZodOptional<z.ZodEnum<{
+                isometric: "isometric";
+                pixel: "pixel";
+                vector: "vector";
+                hd: "hd";
+                "1-bit": "1-bit";
+            }>>;
+            variant: z.ZodOptional<z.ZodString>;
+            dimension: z.ZodOptional<z.ZodEnum<{
+                "2d": "2d";
+                "3d": "3d";
+            }>>;
+            aspect: z.ZodOptional<z.ZodEnum<{
+                "1:1": "1:1";
+                "16:9": "16:9";
+                "5:7": "5:7";
+                "8:1": "8:1";
+                "4:1": "4:1";
+                "5:3": "5:3";
+                "1:2": "1:2";
+            }>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    typeParams: z.ZodOptional<z.ZodArray<z.ZodType<TraitTypeParamDef, unknown, z.core.$ZodTypeInternals<TraitTypeParamDef, unknown>>>>;
+}, z.core.$strip>;
+declare const TraitRefSchema: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    ref: z.ZodString;
+    refId: z.ZodOptional<z.ZodString & z.ZodType<TraitId, string, z.core.$ZodTypeInternals<TraitId, string>>>;
+    id: z.ZodOptional<z.ZodString & z.ZodType<TraitId, string, z.core.$ZodTypeInternals<TraitId, string>>>;
+    from: z.ZodOptional<z.ZodString>;
+    linkedEntity: z.ZodOptional<z.ZodString>;
+    linkedEntityId: z.ZodOptional<z.ZodString & z.ZodType<EntityId, string, z.core.$ZodTypeInternals<EntityId, string>>>;
+    name: z.ZodOptional<z.ZodString>;
+    events: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    eventIds: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>>;
+    _resolved: z.ZodOptional<z.ZodLazy<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString & z.ZodType<TraitId, string, z.core.$ZodTypeInternals<TraitId, string>>>;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        description_visual_prompt: z.ZodOptional<z.ZodString>;
+        entityRebindable: z.ZodOptional<z.ZodBoolean>;
+        entityContract: z.ZodOptional<z.ZodObject<{
+            requires: z.ZodArray<z.ZodString>;
+            provides: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+        effectRow: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            kind: z.ZodString;
+            resource: z.ZodOptional<z.ZodString>;
+            resolved: z.ZodOptional<z.ZodBoolean>;
+            site: z.ZodOptional<z.ZodEnum<{
+                transition: "transition";
+                tick: "tick";
+            }>>;
+        }, z.core.$strip>>>;
+        entityBindingDescription: z.ZodOptional<z.ZodString>;
+        entityBindingSynonyms: z.ZodOptional<z.ZodString>;
+        dispatch: z.ZodOptional<z.ZodEnum<{
+            client: "client";
+            optimistic: "optimistic";
+            server: "server";
+        }>>;
+        linkedEntity: z.ZodOptional<z.ZodString>;
+        linkedEntityId: z.ZodOptional<z.ZodString & z.ZodType<EntityId, string, z.core.$ZodTypeInternals<EntityId, string>>>;
+        entityRefIds: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString & z.ZodType<EntityId, string, z.core.$ZodTypeInternals<EntityId, string>>>>;
+        traitEmbedIds: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString & z.ZodType<TraitId, string, z.core.$ZodTypeInternals<TraitId, string>>>>;
+        requiredFields: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodUnion<readonly [z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                object: "object";
+                date: "date";
+                array: "array";
+                tuple: "tuple";
+                union: "union";
+                enum: "enum";
+                pattern: "pattern";
+                trait: "trait";
+                event: "event";
+                node: "node";
+                url: "url";
+                field: "field";
+                timestamp: "timestamp";
+                image: "image";
+                slot: "slot";
+                datetime: "datetime";
+                instant: "instant";
+                email: "email";
+                phone: "phone";
+                uuid: "uuid";
+                bytes: "bytes";
+                EventAddress: "EventAddress";
+                CallKey: "CallKey";
+                SExpr: "SExpr";
+            }>, z.ZodCustom<`$${string}`, `$${string}`>]>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        dataEntities: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            collection: z.ZodOptional<z.ZodString>;
+            fields: z.ZodArray<z.ZodType<TraitEntityField, object, z.core.$ZodTypeInternals<TraitEntityField, object>>>;
+            timestamps: z.ZodOptional<z.ZodBoolean>;
+            description: z.ZodOptional<z.ZodString>;
+            runtime: z.ZodOptional<z.ZodBoolean>;
+            singleton: z.ZodOptional<z.ZodBoolean>;
+            pages: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>;
+        stateMachine: z.ZodOptional<z.ZodObject<{
+            states: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                isInitial: z.ZodOptional<z.ZodBoolean>;
+                isTerminal: z.ZodOptional<z.ZodBoolean>;
+                isFinal: z.ZodOptional<z.ZodBoolean>;
+                description: z.ZodOptional<z.ZodString>;
+                onEntry: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                onExit: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                holds: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+            }, z.core.$strip>>;
+            events: z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                id: z.ZodOptional<z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>;
+                name: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                synonyms: z.ZodOptional<z.ZodString>;
+                tier: z.ZodOptional<z.ZodString>;
+                payloadSchema: z.ZodOptional<z.ZodArray<z.ZodType<PayloadField, unknown, z.core.$ZodTypeInternals<PayloadField, unknown>>>>;
+                payloadEntity: z.ZodOptional<z.ZodString>;
+                input: z.ZodOptional<z.ZodBoolean>;
+                listened: z.ZodOptional<z.ZodBoolean>;
+                inbound: z.ZodOptional<z.ZodObject<{
+                    name: z.ZodString;
+                    answers: z.ZodString;
+                    verifies: z.ZodOptional<z.ZodObject<{
+                        header: z.ZodString;
+                        credential: z.ZodString;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
+                classification: z.ZodOptional<z.ZodEnum<{
+                    domain: "domain";
+                    system: "system";
+                }>>;
+                semanticRole: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            transitions: z.ZodArray<z.ZodObject<{
+                from: z.ZodString;
+                to: z.ZodString;
+                event: z.ZodString;
+                eventId: z.ZodOptional<z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>;
+                guard: z.ZodOptional<z.ZodNullable<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>>;
+                effects: z.ZodOptional<z.ZodArray<z.ZodType<TypedEffect, unknown, z.core.$ZodTypeInternals<TypedEffect, unknown>>>>;
+                ensures: z.ZodOptional<z.ZodType<SExpr[], unknown, z.core.$ZodTypeInternals<SExpr[], unknown>>>;
+                description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                awaitRender: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    trait: z.ZodString;
+                    slot: z.ZodString;
+                    skeleton: z.ZodType<SkeletonNode, unknown, z.core.$ZodTypeInternals<SkeletonNode, unknown>>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>>;
+            guards: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                expression: z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+        initialEffects: z.ZodOptional<z.ZodArray<z.ZodType<TypedEffect, unknown, z.core.$ZodTypeInternals<TypedEffect, unknown>>>>;
+        ticks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            priority: z.ZodOptional<z.ZodNumber>;
+            interval: z.ZodUnion<readonly [z.ZodLiteral<"frame">, z.ZodNumber, z.ZodString]>;
+            appliesTo: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            runsInBackground: z.ZodOptional<z.ZodBoolean>;
+            whileVisible: z.ZodOptional<z.ZodBoolean>;
+            pages: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            pageIds: z.ZodOptional<z.ZodArray<z.ZodString & z.ZodType<PageId, string, z.core.$ZodTypeInternals<PageId, string>>>>;
+            guard: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+            effects: z.ZodArray<z.ZodType<TypedEffect, unknown, z.core.$ZodTypeInternals<TypedEffect, unknown>>>;
+            emits: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            emitIds: z.ZodOptional<z.ZodArray<z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>>;
+        }, z.core.$strip>>>;
+        emits: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            event: z.ZodString;
+            eventId: z.ZodOptional<z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>;
+            description: z.ZodOptional<z.ZodString>;
+            synonyms: z.ZodOptional<z.ZodString>;
+            tier: z.ZodOptional<z.ZodString>;
+            definerKnob: z.ZodOptional<z.ZodString>;
+            scopeOverridden: z.ZodOptional<z.ZodBoolean>;
+            payloadSchema: z.ZodOptional<z.ZodArray<z.ZodType<PayloadField, unknown, z.core.$ZodTypeInternals<PayloadField, unknown>>>>;
+            payloadEntity: z.ZodOptional<z.ZodString>;
+            scope: z.ZodOptional<z.ZodEnum<{
+                external: "external";
+                internal: "internal";
+            }>>;
+        }, z.core.$strip>>>;
+        listens: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            event: z.ZodString;
+            eventId: z.ZodOptional<z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>;
+            triggers: z.ZodString;
+            triggersId: z.ZodOptional<z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>;
+            description: z.ZodOptional<z.ZodString>;
+            synonyms: z.ZodOptional<z.ZodString>;
+            tier: z.ZodOptional<z.ZodString>;
+            guard: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+            scope: z.ZodOptional<z.ZodEnum<{
+                external: "external";
+                internal: "internal";
+            }>>;
+            payloadMapping: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>>;
+            key: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+            source: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                kind: z.ZodLiteral<"any">;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"trait">;
+                trait: z.ZodString;
+                traitId: z.ZodOptional<z.ZodString & z.ZodType<TraitId, string, z.core.$ZodTypeInternals<TraitId, string>>>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"orbital">;
+                orbital: z.ZodString;
+                trait: z.ZodString;
+                orbitalId: z.ZodOptional<z.ZodString & z.ZodType<OrbitalId, string, z.core.$ZodTypeInternals<OrbitalId, string>>>;
+                traitId: z.ZodOptional<z.ZodString & z.ZodType<TraitId, string, z.core.$ZodTypeInternals<TraitId, string>>>;
+            }, z.core.$strip>]>>;
+        }, z.core.$strip>>>;
+        events: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        ui: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            presentation: z.ZodEnum<{
+                modal: "modal";
+                drawer: "drawer";
+                "confirm-dialog": "confirm-dialog";
+                popover: "popover";
+                inline: "inline";
+            }>;
+            content: z.ZodUnion<readonly [z.ZodType<AnyPatternConfig, unknown, z.core.$ZodTypeInternals<AnyPatternConfig, unknown>>, z.ZodArray<z.ZodType<AnyPatternConfig, unknown, z.core.$ZodTypeInternals<AnyPatternConfig, unknown>>>]>;
+            props: z.ZodOptional<z.ZodObject<{
+                size: z.ZodOptional<z.ZodEnum<{
+                    md: "md";
+                    sm: "sm";
+                    full: "full";
+                    lg: "lg";
+                    xl: "xl";
+                }>>;
+                position: z.ZodOptional<z.ZodEnum<{
+                    right: "right";
+                    center: "center";
+                    top: "top";
+                    bottom: "bottom";
+                    left: "left";
+                }>>;
+                title: z.ZodOptional<z.ZodString>;
+                closable: z.ZodOptional<z.ZodBoolean>;
+                width: z.ZodOptional<z.ZodString>;
+                showProgress: z.ZodOptional<z.ZodBoolean>;
+                step: z.ZodOptional<z.ZodNumber>;
+                totalSteps: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+        config: z.ZodOptional<z.ZodType<Readonly<Record<string, ConfigFieldDeclaration>>, Record<string, object>, z.core.$ZodTypeInternals<Readonly<Record<string, ConfigFieldDeclaration>>, Record<string, object>>>>;
+        sourceBehavior: z.ZodOptional<z.ZodObject<{
+            behavior: z.ZodString;
+            alias: z.ZodString;
+            originalName: z.ZodString;
+        }, z.core.$strip>>;
+        sourceDeclaration: z.ZodOptional<z.ZodObject<{
+            traitId: z.ZodString;
+            fingerprint: z.ZodString;
+        }, z.core.$strip>>;
+        sourceEntityDefinition: z.ZodOptional<z.ZodObject<{
+            name: z.ZodString;
+            id: z.ZodOptional<z.ZodString & z.ZodType<EntityId, string, z.core.$ZodTypeInternals<EntityId, string>>>;
+            persistence: z.ZodDefault<z.ZodEnum<{
+                persistent: "persistent";
+                runtime: "runtime";
+            }>>;
+            shared: z.ZodOptional<z.ZodBoolean>;
+            identity: z.ZodOptional<z.ZodBoolean>;
+            browser: z.ZodOptional<z.ZodBoolean>;
+            store: z.ZodOptional<z.ZodString>;
+            read_policy: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+            create_policy: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+            update_policy: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+            delete_policy: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+            access_waivers: z.ZodOptional<z.ZodObject<{
+                read: z.ZodOptional<z.ZodString>;
+                create: z.ZodOptional<z.ZodString>;
+                update: z.ZodOptional<z.ZodString>;
+                delete: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            invariants: z.ZodOptional<z.ZodType<SExpr[], unknown, z.core.$ZodTypeInternals<SExpr[], unknown>>>;
+            indexes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                fields: z.ZodArray<z.ZodString>;
+                orderBy: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            collection: z.ZodOptional<z.ZodString>;
+            fields: z.ZodArray<z.ZodType<EntityField, unknown, z.core.$ZodTypeInternals<EntityField, unknown>>>;
+            instances: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>>;
+            localeInstances: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>>>;
+            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>>;
+                style: z.ZodOptional<z.ZodEnum<{
+                    isometric: "isometric";
+                    pixel: "pixel";
+                    vector: "vector";
+                    hd: "hd";
+                    "1-bit": "1-bit";
+                }>>;
+                variant: z.ZodOptional<z.ZodString>;
+                dimension: z.ZodOptional<z.ZodEnum<{
+                    "2d": "2d";
+                    "3d": "3d";
+                }>>;
+                aspect: z.ZodOptional<z.ZodEnum<{
+                    "1:1": "1:1";
+                    "16:9": "16:9";
+                    "5:7": "5:7";
+                    "8:1": "8:1";
+                    "4:1": "4:1";
+                    "5:3": "5:3";
+                    "1:2": "1:2";
+                }>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        typeParams: z.ZodOptional<z.ZodArray<z.ZodType<TraitTypeParamDef, unknown, z.core.$ZodTypeInternals<TraitTypeParamDef, unknown>>>>;
+    }, z.core.$strip>>>;
+    typeArgs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodType<ConfigFieldDeclaration, object, z.core.$ZodTypeInternals<ConfigFieldDeclaration, object>>, z.ZodType<TraitConfigValue, unknown, z.core.$ZodTypeInternals<TraitConfigValue, unknown>>]>>>;
+    appliesTo: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    listens: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        event: z.ZodString;
+        eventId: z.ZodOptional<z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>;
+        triggers: z.ZodString;
+        triggersId: z.ZodOptional<z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>;
+        description: z.ZodOptional<z.ZodString>;
+        synonyms: z.ZodOptional<z.ZodString>;
+        tier: z.ZodOptional<z.ZodString>;
+        guard: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+        scope: z.ZodOptional<z.ZodEnum<{
+            external: "external";
+            internal: "internal";
+        }>>;
+        payloadMapping: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>>;
+        key: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+        source: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            kind: z.ZodLiteral<"any">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"trait">;
+            trait: z.ZodString;
+            traitId: z.ZodOptional<z.ZodString & z.ZodType<TraitId, string, z.core.$ZodTypeInternals<TraitId, string>>>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"orbital">;
+            orbital: z.ZodString;
+            trait: z.ZodString;
+            orbitalId: z.ZodOptional<z.ZodString & z.ZodType<OrbitalId, string, z.core.$ZodTypeInternals<OrbitalId, string>>>;
+            traitId: z.ZodOptional<z.ZodString & z.ZodType<TraitId, string, z.core.$ZodTypeInternals<TraitId, string>>>;
+        }, z.core.$strip>]>>;
+    }, z.core.$strip>>>;
+    emitsScope: z.ZodOptional<z.ZodEnum<{
+        external: "external";
+        internal: "internal";
+    }>>;
+    effects: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>>>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodOptional<z.ZodString & z.ZodType<TraitId, string, z.core.$ZodTypeInternals<TraitId, string>>>;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    description_visual_prompt: z.ZodOptional<z.ZodString>;
+    entityRebindable: z.ZodOptional<z.ZodBoolean>;
+    entityContract: z.ZodOptional<z.ZodObject<{
+        requires: z.ZodArray<z.ZodString>;
+        provides: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    effectRow: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        kind: z.ZodString;
+        resource: z.ZodOptional<z.ZodString>;
+        resolved: z.ZodOptional<z.ZodBoolean>;
+        site: z.ZodOptional<z.ZodEnum<{
+            transition: "transition";
+            tick: "tick";
+        }>>;
+    }, z.core.$strip>>>;
+    entityBindingDescription: z.ZodOptional<z.ZodString>;
+    entityBindingSynonyms: z.ZodOptional<z.ZodString>;
+    dispatch: z.ZodOptional<z.ZodEnum<{
+        client: "client";
+        optimistic: "optimistic";
+        server: "server";
+    }>>;
+    linkedEntity: z.ZodOptional<z.ZodString>;
+    linkedEntityId: z.ZodOptional<z.ZodString & z.ZodType<EntityId, string, z.core.$ZodTypeInternals<EntityId, string>>>;
+    entityRefIds: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString & z.ZodType<EntityId, string, z.core.$ZodTypeInternals<EntityId, string>>>>;
+    traitEmbedIds: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString & z.ZodType<TraitId, string, z.core.$ZodTypeInternals<TraitId, string>>>>;
+    requiredFields: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodUnion<readonly [z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+            object: "object";
+            date: "date";
+            array: "array";
+            tuple: "tuple";
+            union: "union";
+            enum: "enum";
+            pattern: "pattern";
+            trait: "trait";
+            event: "event";
+            node: "node";
+            url: "url";
+            field: "field";
+            timestamp: "timestamp";
+            image: "image";
+            slot: "slot";
+            datetime: "datetime";
+            instant: "instant";
+            email: "email";
+            phone: "phone";
+            uuid: "uuid";
+            bytes: "bytes";
+            EventAddress: "EventAddress";
+            CallKey: "CallKey";
+            SExpr: "SExpr";
+        }>, z.ZodCustom<`$${string}`, `$${string}`>]>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    dataEntities: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        collection: z.ZodOptional<z.ZodString>;
+        fields: z.ZodArray<z.ZodType<TraitEntityField, object, z.core.$ZodTypeInternals<TraitEntityField, object>>>;
+        timestamps: z.ZodOptional<z.ZodBoolean>;
+        description: z.ZodOptional<z.ZodString>;
+        runtime: z.ZodOptional<z.ZodBoolean>;
+        singleton: z.ZodOptional<z.ZodBoolean>;
+        pages: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    stateMachine: z.ZodOptional<z.ZodObject<{
+        states: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            isInitial: z.ZodOptional<z.ZodBoolean>;
+            isTerminal: z.ZodOptional<z.ZodBoolean>;
+            isFinal: z.ZodOptional<z.ZodBoolean>;
+            description: z.ZodOptional<z.ZodString>;
+            onEntry: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            onExit: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            holds: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+        }, z.core.$strip>>;
+        events: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            id: z.ZodOptional<z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>;
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            synonyms: z.ZodOptional<z.ZodString>;
+            tier: z.ZodOptional<z.ZodString>;
+            payloadSchema: z.ZodOptional<z.ZodArray<z.ZodType<PayloadField, unknown, z.core.$ZodTypeInternals<PayloadField, unknown>>>>;
+            payloadEntity: z.ZodOptional<z.ZodString>;
+            input: z.ZodOptional<z.ZodBoolean>;
+            listened: z.ZodOptional<z.ZodBoolean>;
+            inbound: z.ZodOptional<z.ZodObject<{
+                name: z.ZodString;
+                answers: z.ZodString;
+                verifies: z.ZodOptional<z.ZodObject<{
+                    header: z.ZodString;
+                    credential: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            classification: z.ZodOptional<z.ZodEnum<{
+                domain: "domain";
+                system: "system";
+            }>>;
+            semanticRole: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        transitions: z.ZodArray<z.ZodObject<{
+            from: z.ZodString;
+            to: z.ZodString;
+            event: z.ZodString;
+            eventId: z.ZodOptional<z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>;
+            guard: z.ZodOptional<z.ZodNullable<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>>;
+            effects: z.ZodOptional<z.ZodArray<z.ZodType<TypedEffect, unknown, z.core.$ZodTypeInternals<TypedEffect, unknown>>>>;
+            ensures: z.ZodOptional<z.ZodType<SExpr[], unknown, z.core.$ZodTypeInternals<SExpr[], unknown>>>;
+            description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            awaitRender: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                trait: z.ZodString;
+                slot: z.ZodString;
+                skeleton: z.ZodType<SkeletonNode, unknown, z.core.$ZodTypeInternals<SkeletonNode, unknown>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+        guards: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            expression: z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    initialEffects: z.ZodOptional<z.ZodArray<z.ZodType<TypedEffect, unknown, z.core.$ZodTypeInternals<TypedEffect, unknown>>>>;
+    ticks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        priority: z.ZodOptional<z.ZodNumber>;
+        interval: z.ZodUnion<readonly [z.ZodLiteral<"frame">, z.ZodNumber, z.ZodString]>;
+        appliesTo: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        runsInBackground: z.ZodOptional<z.ZodBoolean>;
+        whileVisible: z.ZodOptional<z.ZodBoolean>;
+        pages: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        pageIds: z.ZodOptional<z.ZodArray<z.ZodString & z.ZodType<PageId, string, z.core.$ZodTypeInternals<PageId, string>>>>;
+        guard: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+        effects: z.ZodArray<z.ZodType<TypedEffect, unknown, z.core.$ZodTypeInternals<TypedEffect, unknown>>>;
+        emits: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        emitIds: z.ZodOptional<z.ZodArray<z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>>;
+    }, z.core.$strip>>>;
+    emits: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        event: z.ZodString;
+        eventId: z.ZodOptional<z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>;
+        description: z.ZodOptional<z.ZodString>;
+        synonyms: z.ZodOptional<z.ZodString>;
+        tier: z.ZodOptional<z.ZodString>;
+        definerKnob: z.ZodOptional<z.ZodString>;
+        scopeOverridden: z.ZodOptional<z.ZodBoolean>;
+        payloadSchema: z.ZodOptional<z.ZodArray<z.ZodType<PayloadField, unknown, z.core.$ZodTypeInternals<PayloadField, unknown>>>>;
+        payloadEntity: z.ZodOptional<z.ZodString>;
+        scope: z.ZodOptional<z.ZodEnum<{
+            external: "external";
+            internal: "internal";
+        }>>;
+    }, z.core.$strip>>>;
+    listens: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        event: z.ZodString;
+        eventId: z.ZodOptional<z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>;
+        triggers: z.ZodString;
+        triggersId: z.ZodOptional<z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>;
+        description: z.ZodOptional<z.ZodString>;
+        synonyms: z.ZodOptional<z.ZodString>;
+        tier: z.ZodOptional<z.ZodString>;
+        guard: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+        scope: z.ZodOptional<z.ZodEnum<{
+            external: "external";
+            internal: "internal";
+        }>>;
+        payloadMapping: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>>;
+        key: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+        source: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            kind: z.ZodLiteral<"any">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"trait">;
+            trait: z.ZodString;
+            traitId: z.ZodOptional<z.ZodString & z.ZodType<TraitId, string, z.core.$ZodTypeInternals<TraitId, string>>>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"orbital">;
+            orbital: z.ZodString;
+            trait: z.ZodString;
+            orbitalId: z.ZodOptional<z.ZodString & z.ZodType<OrbitalId, string, z.core.$ZodTypeInternals<OrbitalId, string>>>;
+            traitId: z.ZodOptional<z.ZodString & z.ZodType<TraitId, string, z.core.$ZodTypeInternals<TraitId, string>>>;
+        }, z.core.$strip>]>>;
+    }, z.core.$strip>>>;
+    events: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    ui: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        presentation: z.ZodEnum<{
+            modal: "modal";
+            drawer: "drawer";
+            "confirm-dialog": "confirm-dialog";
+            popover: "popover";
+            inline: "inline";
+        }>;
+        content: z.ZodUnion<readonly [z.ZodType<AnyPatternConfig, unknown, z.core.$ZodTypeInternals<AnyPatternConfig, unknown>>, z.ZodArray<z.ZodType<AnyPatternConfig, unknown, z.core.$ZodTypeInternals<AnyPatternConfig, unknown>>>]>;
+        props: z.ZodOptional<z.ZodObject<{
+            size: z.ZodOptional<z.ZodEnum<{
+                md: "md";
+                sm: "sm";
+                full: "full";
+                lg: "lg";
+                xl: "xl";
+            }>>;
+            position: z.ZodOptional<z.ZodEnum<{
+                right: "right";
+                center: "center";
+                top: "top";
+                bottom: "bottom";
+                left: "left";
+            }>>;
+            title: z.ZodOptional<z.ZodString>;
+            closable: z.ZodOptional<z.ZodBoolean>;
+            width: z.ZodOptional<z.ZodString>;
+            showProgress: z.ZodOptional<z.ZodBoolean>;
+            step: z.ZodOptional<z.ZodNumber>;
+            totalSteps: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    config: z.ZodOptional<z.ZodType<Readonly<Record<string, ConfigFieldDeclaration>>, Record<string, object>, z.core.$ZodTypeInternals<Readonly<Record<string, ConfigFieldDeclaration>>, Record<string, object>>>>;
+    sourceBehavior: z.ZodOptional<z.ZodObject<{
+        behavior: z.ZodString;
+        alias: z.ZodString;
+        originalName: z.ZodString;
+    }, z.core.$strip>>;
+    sourceDeclaration: z.ZodOptional<z.ZodObject<{
+        traitId: z.ZodString;
+        fingerprint: z.ZodString;
+    }, z.core.$strip>>;
+    sourceEntityDefinition: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        id: z.ZodOptional<z.ZodString & z.ZodType<EntityId, string, z.core.$ZodTypeInternals<EntityId, string>>>;
+        persistence: z.ZodDefault<z.ZodEnum<{
+            persistent: "persistent";
+            runtime: "runtime";
+        }>>;
+        shared: z.ZodOptional<z.ZodBoolean>;
+        identity: z.ZodOptional<z.ZodBoolean>;
+        browser: z.ZodOptional<z.ZodBoolean>;
+        store: z.ZodOptional<z.ZodString>;
+        read_policy: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+        create_policy: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+        update_policy: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+        delete_policy: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+        access_waivers: z.ZodOptional<z.ZodObject<{
+            read: z.ZodOptional<z.ZodString>;
+            create: z.ZodOptional<z.ZodString>;
+            update: z.ZodOptional<z.ZodString>;
+            delete: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        invariants: z.ZodOptional<z.ZodType<SExpr[], unknown, z.core.$ZodTypeInternals<SExpr[], unknown>>>;
+        indexes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            fields: z.ZodArray<z.ZodString>;
+            orderBy: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        collection: z.ZodOptional<z.ZodString>;
+        fields: z.ZodArray<z.ZodType<EntityField, unknown, z.core.$ZodTypeInternals<EntityField, unknown>>>;
+        instances: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>>;
+        localeInstances: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>>>;
+        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>>;
+            style: z.ZodOptional<z.ZodEnum<{
+                isometric: "isometric";
+                pixel: "pixel";
+                vector: "vector";
+                hd: "hd";
+                "1-bit": "1-bit";
+            }>>;
+            variant: z.ZodOptional<z.ZodString>;
+            dimension: z.ZodOptional<z.ZodEnum<{
+                "2d": "2d";
+                "3d": "3d";
+            }>>;
+            aspect: z.ZodOptional<z.ZodEnum<{
+                "1:1": "1:1";
+                "16:9": "16:9";
+                "5:7": "5:7";
+                "8:1": "8:1";
+                "4:1": "4:1";
+                "5:3": "5:3";
+                "1:2": "1:2";
+            }>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    typeParams: z.ZodOptional<z.ZodArray<z.ZodType<TraitTypeParamDef, unknown, z.core.$ZodTypeInternals<TraitTypeParamDef, unknown>>>>;
+}, z.core.$strip>]>;
+/**
+ * Check if a trait ref is an inline Trait definition
+ */
+/**
+ * Checks if a trait reference is an inline trait definition.
+ *
+ * Type guard to determine if a TraitRef is an inline trait object
+ * (with 'name' property) rather than a string reference or object reference.
+ *
+ * @param {TraitRef} traitRef - Trait reference to check
+ * @returns {boolean} True if traitRef is an inline trait, false otherwise
+ *
+ * @example
+ * isInlineTrait({ name: 'MyTrait' }); // returns true (inline)
+ * isInlineTrait('MyTrait'); // returns false (string reference)
+ * isInlineTrait({ ref: 'MyTrait' }); // returns false (object reference)
+ */
+declare function isInlineTrait(traitRef: TraitRef): traitRef is Trait;
+/**
+ * Extracts the trait name from a trait reference.
+ *
+ * Handles all trait reference formats (string, inline object, object reference)
+ * and returns the canonical trait name.
+ *
+ * @param {TraitRef} traitRef - Trait reference to extract name from
+ * @returns {string} Trait name
+ *
+ * @example
+ * getTraitName('MyTrait'); // returns 'MyTrait'
+ * getTraitName({ name: 'MyTrait' }); // returns 'MyTrait'
+ * getTraitName({ ref: 'MyTrait' }); // returns 'MyTrait'
+ */
+declare function getTraitName(traitRef: TraitRef): string;
+/**
+ * Extracts the configuration from a trait reference.
+ *
+ * Returns the configuration object for trait references that support it
+ * (object references with 'config' property). Returns undefined for
+ * string references and inline traits.
+ *
+ * @param {TraitRef} traitRef - Trait reference to extract config from
+ * @returns {TraitConfig | undefined} Trait configuration or undefined
+ *
+ * @example
+ * getTraitConfig('MyTrait'); // returns undefined
+ * getTraitConfig({ name: 'MyTrait' }); // returns undefined
+ * getTraitConfig({ ref: 'MyTrait', config: { option: 'value' } }); // returns config object
+ */
+declare function getTraitConfig(traitRef: TraitRef): CallSiteConfig | undefined;
+/**
+ * Normalizes a trait reference to object form.
+ *
+ * Converts any trait reference format (string, inline, object) to a
+ * standardized object format with 'ref' and optional 'config' properties.
+ *
+ * @param {TraitRef} traitRef - Trait reference to normalize
+ * @returns {{ ref: string; config?: TraitConfig }} Normalized trait reference
+ *
+ * @example
+ * normalizeTraitRef('MyTrait'); // returns { ref: 'MyTrait' }
+ * normalizeTraitRef({ name: 'MyTrait' }); // returns { ref: 'MyTrait' }
+ * normalizeTraitRef({ ref: 'MyTrait', config: {...} }); // returns original
+ */
+declare function normalizeTraitRef(traitRef: TraitRef): {
+    ref: string;
+    config?: CallSiteConfig;
+};
+type TraitInput = z.input<typeof TraitSchema>;
+type TraitReferenceInput = z.input<typeof TraitReferenceSchema>;
+type OrbitalTraitRef = TraitRef;
+declare const OrbitalTraitRefSchema: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    ref: z.ZodString;
+    refId: z.ZodOptional<z.ZodString & z.ZodType<TraitId, string, z.core.$ZodTypeInternals<TraitId, string>>>;
+    id: z.ZodOptional<z.ZodString & z.ZodType<TraitId, string, z.core.$ZodTypeInternals<TraitId, string>>>;
+    from: z.ZodOptional<z.ZodString>;
+    linkedEntity: z.ZodOptional<z.ZodString>;
+    linkedEntityId: z.ZodOptional<z.ZodString & z.ZodType<EntityId, string, z.core.$ZodTypeInternals<EntityId, string>>>;
+    name: z.ZodOptional<z.ZodString>;
+    events: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    eventIds: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>>;
+    _resolved: z.ZodOptional<z.ZodLazy<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString & z.ZodType<TraitId, string, z.core.$ZodTypeInternals<TraitId, string>>>;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        description_visual_prompt: z.ZodOptional<z.ZodString>;
+        entityRebindable: z.ZodOptional<z.ZodBoolean>;
+        entityContract: z.ZodOptional<z.ZodObject<{
+            requires: z.ZodArray<z.ZodString>;
+            provides: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+        effectRow: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            kind: z.ZodString;
+            resource: z.ZodOptional<z.ZodString>;
+            resolved: z.ZodOptional<z.ZodBoolean>;
+            site: z.ZodOptional<z.ZodEnum<{
+                transition: "transition";
+                tick: "tick";
+            }>>;
+        }, z.core.$strip>>>;
+        entityBindingDescription: z.ZodOptional<z.ZodString>;
+        entityBindingSynonyms: z.ZodOptional<z.ZodString>;
+        dispatch: z.ZodOptional<z.ZodEnum<{
+            client: "client";
+            optimistic: "optimistic";
+            server: "server";
+        }>>;
+        linkedEntity: z.ZodOptional<z.ZodString>;
+        linkedEntityId: z.ZodOptional<z.ZodString & z.ZodType<EntityId, string, z.core.$ZodTypeInternals<EntityId, string>>>;
+        entityRefIds: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString & z.ZodType<EntityId, string, z.core.$ZodTypeInternals<EntityId, string>>>>;
+        traitEmbedIds: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString & z.ZodType<TraitId, string, z.core.$ZodTypeInternals<TraitId, string>>>>;
+        requiredFields: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodUnion<readonly [z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                object: "object";
+                date: "date";
+                array: "array";
+                tuple: "tuple";
+                union: "union";
+                enum: "enum";
+                pattern: "pattern";
+                trait: "trait";
+                event: "event";
+                node: "node";
+                url: "url";
+                field: "field";
+                timestamp: "timestamp";
+                image: "image";
+                slot: "slot";
+                datetime: "datetime";
+                instant: "instant";
+                email: "email";
+                phone: "phone";
+                uuid: "uuid";
+                bytes: "bytes";
+                EventAddress: "EventAddress";
+                CallKey: "CallKey";
+                SExpr: "SExpr";
+            }>, z.ZodCustom<`$${string}`, `$${string}`>]>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        dataEntities: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            collection: z.ZodOptional<z.ZodString>;
+            fields: z.ZodArray<z.ZodType<TraitEntityField, object, z.core.$ZodTypeInternals<TraitEntityField, object>>>;
+            timestamps: z.ZodOptional<z.ZodBoolean>;
+            description: z.ZodOptional<z.ZodString>;
+            runtime: z.ZodOptional<z.ZodBoolean>;
+            singleton: z.ZodOptional<z.ZodBoolean>;
+            pages: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>;
+        stateMachine: z.ZodOptional<z.ZodObject<{
+            states: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                isInitial: z.ZodOptional<z.ZodBoolean>;
+                isTerminal: z.ZodOptional<z.ZodBoolean>;
+                isFinal: z.ZodOptional<z.ZodBoolean>;
+                description: z.ZodOptional<z.ZodString>;
+                onEntry: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                onExit: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                holds: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+            }, z.core.$strip>>;
+            events: z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                id: z.ZodOptional<z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>;
+                name: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                synonyms: z.ZodOptional<z.ZodString>;
+                tier: z.ZodOptional<z.ZodString>;
+                payloadSchema: z.ZodOptional<z.ZodArray<z.ZodType<PayloadField, unknown, z.core.$ZodTypeInternals<PayloadField, unknown>>>>;
+                payloadEntity: z.ZodOptional<z.ZodString>;
+                input: z.ZodOptional<z.ZodBoolean>;
+                listened: z.ZodOptional<z.ZodBoolean>;
+                inbound: z.ZodOptional<z.ZodObject<{
+                    name: z.ZodString;
+                    answers: z.ZodString;
+                    verifies: z.ZodOptional<z.ZodObject<{
+                        header: z.ZodString;
+                        credential: z.ZodString;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
+                classification: z.ZodOptional<z.ZodEnum<{
+                    domain: "domain";
+                    system: "system";
+                }>>;
+                semanticRole: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            transitions: z.ZodArray<z.ZodObject<{
+                from: z.ZodString;
+                to: z.ZodString;
+                event: z.ZodString;
+                eventId: z.ZodOptional<z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>;
+                guard: z.ZodOptional<z.ZodNullable<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>>;
+                effects: z.ZodOptional<z.ZodArray<z.ZodType<TypedEffect, unknown, z.core.$ZodTypeInternals<TypedEffect, unknown>>>>;
+                ensures: z.ZodOptional<z.ZodType<SExpr[], unknown, z.core.$ZodTypeInternals<SExpr[], unknown>>>;
+                description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                awaitRender: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    trait: z.ZodString;
+                    slot: z.ZodString;
+                    skeleton: z.ZodType<SkeletonNode, unknown, z.core.$ZodTypeInternals<SkeletonNode, unknown>>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>>;
+            guards: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                expression: z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+        initialEffects: z.ZodOptional<z.ZodArray<z.ZodType<TypedEffect, unknown, z.core.$ZodTypeInternals<TypedEffect, unknown>>>>;
+        ticks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            priority: z.ZodOptional<z.ZodNumber>;
+            interval: z.ZodUnion<readonly [z.ZodLiteral<"frame">, z.ZodNumber, z.ZodString]>;
+            appliesTo: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            runsInBackground: z.ZodOptional<z.ZodBoolean>;
+            whileVisible: z.ZodOptional<z.ZodBoolean>;
+            pages: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            pageIds: z.ZodOptional<z.ZodArray<z.ZodString & z.ZodType<PageId, string, z.core.$ZodTypeInternals<PageId, string>>>>;
+            guard: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+            effects: z.ZodArray<z.ZodType<TypedEffect, unknown, z.core.$ZodTypeInternals<TypedEffect, unknown>>>;
+            emits: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            emitIds: z.ZodOptional<z.ZodArray<z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>>;
+        }, z.core.$strip>>>;
+        emits: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            event: z.ZodString;
+            eventId: z.ZodOptional<z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>;
+            description: z.ZodOptional<z.ZodString>;
+            synonyms: z.ZodOptional<z.ZodString>;
+            tier: z.ZodOptional<z.ZodString>;
+            definerKnob: z.ZodOptional<z.ZodString>;
+            scopeOverridden: z.ZodOptional<z.ZodBoolean>;
+            payloadSchema: z.ZodOptional<z.ZodArray<z.ZodType<PayloadField, unknown, z.core.$ZodTypeInternals<PayloadField, unknown>>>>;
+            payloadEntity: z.ZodOptional<z.ZodString>;
+            scope: z.ZodOptional<z.ZodEnum<{
+                external: "external";
+                internal: "internal";
+            }>>;
+        }, z.core.$strip>>>;
+        listens: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            event: z.ZodString;
+            eventId: z.ZodOptional<z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>;
+            triggers: z.ZodString;
+            triggersId: z.ZodOptional<z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>;
+            description: z.ZodOptional<z.ZodString>;
+            synonyms: z.ZodOptional<z.ZodString>;
+            tier: z.ZodOptional<z.ZodString>;
+            guard: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+            scope: z.ZodOptional<z.ZodEnum<{
+                external: "external";
+                internal: "internal";
+            }>>;
+            payloadMapping: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>>;
+            key: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+            source: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                kind: z.ZodLiteral<"any">;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"trait">;
+                trait: z.ZodString;
+                traitId: z.ZodOptional<z.ZodString & z.ZodType<TraitId, string, z.core.$ZodTypeInternals<TraitId, string>>>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"orbital">;
+                orbital: z.ZodString;
+                trait: z.ZodString;
+                orbitalId: z.ZodOptional<z.ZodString & z.ZodType<OrbitalId, string, z.core.$ZodTypeInternals<OrbitalId, string>>>;
+                traitId: z.ZodOptional<z.ZodString & z.ZodType<TraitId, string, z.core.$ZodTypeInternals<TraitId, string>>>;
+            }, z.core.$strip>]>>;
+        }, z.core.$strip>>>;
+        events: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        ui: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            presentation: z.ZodEnum<{
+                modal: "modal";
+                drawer: "drawer";
+                "confirm-dialog": "confirm-dialog";
+                popover: "popover";
+                inline: "inline";
+            }>;
+            content: z.ZodUnion<readonly [z.ZodType<AnyPatternConfig, unknown, z.core.$ZodTypeInternals<AnyPatternConfig, unknown>>, z.ZodArray<z.ZodType<AnyPatternConfig, unknown, z.core.$ZodTypeInternals<AnyPatternConfig, unknown>>>]>;
+            props: z.ZodOptional<z.ZodObject<{
+                size: z.ZodOptional<z.ZodEnum<{
+                    md: "md";
+                    sm: "sm";
+                    full: "full";
+                    lg: "lg";
+                    xl: "xl";
+                }>>;
+                position: z.ZodOptional<z.ZodEnum<{
+                    right: "right";
+                    center: "center";
+                    top: "top";
+                    bottom: "bottom";
+                    left: "left";
+                }>>;
+                title: z.ZodOptional<z.ZodString>;
+                closable: z.ZodOptional<z.ZodBoolean>;
+                width: z.ZodOptional<z.ZodString>;
+                showProgress: z.ZodOptional<z.ZodBoolean>;
+                step: z.ZodOptional<z.ZodNumber>;
+                totalSteps: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+        config: z.ZodOptional<z.ZodType<Readonly<Record<string, ConfigFieldDeclaration>>, Record<string, object>, z.core.$ZodTypeInternals<Readonly<Record<string, ConfigFieldDeclaration>>, Record<string, object>>>>;
+        sourceBehavior: z.ZodOptional<z.ZodObject<{
+            behavior: z.ZodString;
+            alias: z.ZodString;
+            originalName: z.ZodString;
+        }, z.core.$strip>>;
+        sourceDeclaration: z.ZodOptional<z.ZodObject<{
+            traitId: z.ZodString;
+            fingerprint: z.ZodString;
+        }, z.core.$strip>>;
+        sourceEntityDefinition: z.ZodOptional<z.ZodObject<{
+            name: z.ZodString;
+            id: z.ZodOptional<z.ZodString & z.ZodType<EntityId, string, z.core.$ZodTypeInternals<EntityId, string>>>;
+            persistence: z.ZodDefault<z.ZodEnum<{
+                persistent: "persistent";
+                runtime: "runtime";
+            }>>;
+            shared: z.ZodOptional<z.ZodBoolean>;
+            identity: z.ZodOptional<z.ZodBoolean>;
+            browser: z.ZodOptional<z.ZodBoolean>;
+            store: z.ZodOptional<z.ZodString>;
+            read_policy: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+            create_policy: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+            update_policy: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+            delete_policy: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+            access_waivers: z.ZodOptional<z.ZodObject<{
+                read: z.ZodOptional<z.ZodString>;
+                create: z.ZodOptional<z.ZodString>;
+                update: z.ZodOptional<z.ZodString>;
+                delete: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            invariants: z.ZodOptional<z.ZodType<SExpr[], unknown, z.core.$ZodTypeInternals<SExpr[], unknown>>>;
+            indexes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                fields: z.ZodArray<z.ZodString>;
+                orderBy: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            collection: z.ZodOptional<z.ZodString>;
+            fields: z.ZodArray<z.ZodType<EntityField, unknown, z.core.$ZodTypeInternals<EntityField, unknown>>>;
+            instances: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>>;
+            localeInstances: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>>>;
+            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>>;
+                style: z.ZodOptional<z.ZodEnum<{
+                    isometric: "isometric";
+                    pixel: "pixel";
+                    vector: "vector";
+                    hd: "hd";
+                    "1-bit": "1-bit";
+                }>>;
+                variant: z.ZodOptional<z.ZodString>;
+                dimension: z.ZodOptional<z.ZodEnum<{
+                    "2d": "2d";
+                    "3d": "3d";
+                }>>;
+                aspect: z.ZodOptional<z.ZodEnum<{
+                    "1:1": "1:1";
+                    "16:9": "16:9";
+                    "5:7": "5:7";
+                    "8:1": "8:1";
+                    "4:1": "4:1";
+                    "5:3": "5:3";
+                    "1:2": "1:2";
+                }>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        typeParams: z.ZodOptional<z.ZodArray<z.ZodType<TraitTypeParamDef, unknown, z.core.$ZodTypeInternals<TraitTypeParamDef, unknown>>>>;
+    }, z.core.$strip>>>;
+    typeArgs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodType<ConfigFieldDeclaration, object, z.core.$ZodTypeInternals<ConfigFieldDeclaration, object>>, z.ZodType<TraitConfigValue, unknown, z.core.$ZodTypeInternals<TraitConfigValue, unknown>>]>>>;
+    appliesTo: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    listens: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        event: z.ZodString;
+        eventId: z.ZodOptional<z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>;
+        triggers: z.ZodString;
+        triggersId: z.ZodOptional<z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>;
+        description: z.ZodOptional<z.ZodString>;
+        synonyms: z.ZodOptional<z.ZodString>;
+        tier: z.ZodOptional<z.ZodString>;
+        guard: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+        scope: z.ZodOptional<z.ZodEnum<{
+            external: "external";
+            internal: "internal";
+        }>>;
+        payloadMapping: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>>;
+        key: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+        source: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            kind: z.ZodLiteral<"any">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"trait">;
+            trait: z.ZodString;
+            traitId: z.ZodOptional<z.ZodString & z.ZodType<TraitId, string, z.core.$ZodTypeInternals<TraitId, string>>>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"orbital">;
+            orbital: z.ZodString;
+            trait: z.ZodString;
+            orbitalId: z.ZodOptional<z.ZodString & z.ZodType<OrbitalId, string, z.core.$ZodTypeInternals<OrbitalId, string>>>;
+            traitId: z.ZodOptional<z.ZodString & z.ZodType<TraitId, string, z.core.$ZodTypeInternals<TraitId, string>>>;
+        }, z.core.$strip>]>>;
+    }, z.core.$strip>>>;
+    emitsScope: z.ZodOptional<z.ZodEnum<{
+        external: "external";
+        internal: "internal";
+    }>>;
+    effects: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>>>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodOptional<z.ZodString & z.ZodType<TraitId, string, z.core.$ZodTypeInternals<TraitId, string>>>;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    description_visual_prompt: z.ZodOptional<z.ZodString>;
+    entityRebindable: z.ZodOptional<z.ZodBoolean>;
+    entityContract: z.ZodOptional<z.ZodObject<{
+        requires: z.ZodArray<z.ZodString>;
+        provides: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    effectRow: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        kind: z.ZodString;
+        resource: z.ZodOptional<z.ZodString>;
+        resolved: z.ZodOptional<z.ZodBoolean>;
+        site: z.ZodOptional<z.ZodEnum<{
+            transition: "transition";
+            tick: "tick";
+        }>>;
+    }, z.core.$strip>>>;
+    entityBindingDescription: z.ZodOptional<z.ZodString>;
+    entityBindingSynonyms: z.ZodOptional<z.ZodString>;
+    dispatch: z.ZodOptional<z.ZodEnum<{
+        client: "client";
+        optimistic: "optimistic";
+        server: "server";
+    }>>;
+    linkedEntity: z.ZodOptional<z.ZodString>;
+    linkedEntityId: z.ZodOptional<z.ZodString & z.ZodType<EntityId, string, z.core.$ZodTypeInternals<EntityId, string>>>;
+    entityRefIds: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString & z.ZodType<EntityId, string, z.core.$ZodTypeInternals<EntityId, string>>>>;
+    traitEmbedIds: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString & z.ZodType<TraitId, string, z.core.$ZodTypeInternals<TraitId, string>>>>;
+    requiredFields: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodUnion<readonly [z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+            object: "object";
+            date: "date";
+            array: "array";
+            tuple: "tuple";
+            union: "union";
+            enum: "enum";
+            pattern: "pattern";
+            trait: "trait";
+            event: "event";
+            node: "node";
+            url: "url";
+            field: "field";
+            timestamp: "timestamp";
+            image: "image";
+            slot: "slot";
+            datetime: "datetime";
+            instant: "instant";
+            email: "email";
+            phone: "phone";
+            uuid: "uuid";
+            bytes: "bytes";
+            EventAddress: "EventAddress";
+            CallKey: "CallKey";
+            SExpr: "SExpr";
+        }>, z.ZodCustom<`$${string}`, `$${string}`>]>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    dataEntities: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        collection: z.ZodOptional<z.ZodString>;
+        fields: z.ZodArray<z.ZodType<TraitEntityField, object, z.core.$ZodTypeInternals<TraitEntityField, object>>>;
+        timestamps: z.ZodOptional<z.ZodBoolean>;
+        description: z.ZodOptional<z.ZodString>;
+        runtime: z.ZodOptional<z.ZodBoolean>;
+        singleton: z.ZodOptional<z.ZodBoolean>;
+        pages: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    stateMachine: z.ZodOptional<z.ZodObject<{
+        states: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            isInitial: z.ZodOptional<z.ZodBoolean>;
+            isTerminal: z.ZodOptional<z.ZodBoolean>;
+            isFinal: z.ZodOptional<z.ZodBoolean>;
+            description: z.ZodOptional<z.ZodString>;
+            onEntry: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            onExit: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            holds: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+        }, z.core.$strip>>;
+        events: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            id: z.ZodOptional<z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>;
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            synonyms: z.ZodOptional<z.ZodString>;
+            tier: z.ZodOptional<z.ZodString>;
+            payloadSchema: z.ZodOptional<z.ZodArray<z.ZodType<PayloadField, unknown, z.core.$ZodTypeInternals<PayloadField, unknown>>>>;
+            payloadEntity: z.ZodOptional<z.ZodString>;
+            input: z.ZodOptional<z.ZodBoolean>;
+            listened: z.ZodOptional<z.ZodBoolean>;
+            inbound: z.ZodOptional<z.ZodObject<{
+                name: z.ZodString;
+                answers: z.ZodString;
+                verifies: z.ZodOptional<z.ZodObject<{
+                    header: z.ZodString;
+                    credential: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            classification: z.ZodOptional<z.ZodEnum<{
+                domain: "domain";
+                system: "system";
+            }>>;
+            semanticRole: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        transitions: z.ZodArray<z.ZodObject<{
+            from: z.ZodString;
+            to: z.ZodString;
+            event: z.ZodString;
+            eventId: z.ZodOptional<z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>;
+            guard: z.ZodOptional<z.ZodNullable<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>>;
+            effects: z.ZodOptional<z.ZodArray<z.ZodType<TypedEffect, unknown, z.core.$ZodTypeInternals<TypedEffect, unknown>>>>;
+            ensures: z.ZodOptional<z.ZodType<SExpr[], unknown, z.core.$ZodTypeInternals<SExpr[], unknown>>>;
+            description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            awaitRender: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                trait: z.ZodString;
+                slot: z.ZodString;
+                skeleton: z.ZodType<SkeletonNode, unknown, z.core.$ZodTypeInternals<SkeletonNode, unknown>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+        guards: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            expression: z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    initialEffects: z.ZodOptional<z.ZodArray<z.ZodType<TypedEffect, unknown, z.core.$ZodTypeInternals<TypedEffect, unknown>>>>;
+    ticks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        priority: z.ZodOptional<z.ZodNumber>;
+        interval: z.ZodUnion<readonly [z.ZodLiteral<"frame">, z.ZodNumber, z.ZodString]>;
+        appliesTo: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        runsInBackground: z.ZodOptional<z.ZodBoolean>;
+        whileVisible: z.ZodOptional<z.ZodBoolean>;
+        pages: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        pageIds: z.ZodOptional<z.ZodArray<z.ZodString & z.ZodType<PageId, string, z.core.$ZodTypeInternals<PageId, string>>>>;
+        guard: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+        effects: z.ZodArray<z.ZodType<TypedEffect, unknown, z.core.$ZodTypeInternals<TypedEffect, unknown>>>;
+        emits: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        emitIds: z.ZodOptional<z.ZodArray<z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>>;
+    }, z.core.$strip>>>;
+    emits: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        event: z.ZodString;
+        eventId: z.ZodOptional<z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>;
+        description: z.ZodOptional<z.ZodString>;
+        synonyms: z.ZodOptional<z.ZodString>;
+        tier: z.ZodOptional<z.ZodString>;
+        definerKnob: z.ZodOptional<z.ZodString>;
+        scopeOverridden: z.ZodOptional<z.ZodBoolean>;
+        payloadSchema: z.ZodOptional<z.ZodArray<z.ZodType<PayloadField, unknown, z.core.$ZodTypeInternals<PayloadField, unknown>>>>;
+        payloadEntity: z.ZodOptional<z.ZodString>;
+        scope: z.ZodOptional<z.ZodEnum<{
+            external: "external";
+            internal: "internal";
+        }>>;
+    }, z.core.$strip>>>;
+    listens: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        event: z.ZodString;
+        eventId: z.ZodOptional<z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>;
+        triggers: z.ZodString;
+        triggersId: z.ZodOptional<z.ZodString & z.ZodType<EventId, string, z.core.$ZodTypeInternals<EventId, string>>>;
+        description: z.ZodOptional<z.ZodString>;
+        synonyms: z.ZodOptional<z.ZodString>;
+        tier: z.ZodOptional<z.ZodString>;
+        guard: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+        scope: z.ZodOptional<z.ZodEnum<{
+            external: "external";
+            internal: "internal";
+        }>>;
+        payloadMapping: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>>;
+        key: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+        source: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            kind: z.ZodLiteral<"any">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"trait">;
+            trait: z.ZodString;
+            traitId: z.ZodOptional<z.ZodString & z.ZodType<TraitId, string, z.core.$ZodTypeInternals<TraitId, string>>>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"orbital">;
+            orbital: z.ZodString;
+            trait: z.ZodString;
+            orbitalId: z.ZodOptional<z.ZodString & z.ZodType<OrbitalId, string, z.core.$ZodTypeInternals<OrbitalId, string>>>;
+            traitId: z.ZodOptional<z.ZodString & z.ZodType<TraitId, string, z.core.$ZodTypeInternals<TraitId, string>>>;
+        }, z.core.$strip>]>>;
+    }, z.core.$strip>>>;
+    events: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    ui: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        presentation: z.ZodEnum<{
+            modal: "modal";
+            drawer: "drawer";
+            "confirm-dialog": "confirm-dialog";
+            popover: "popover";
+            inline: "inline";
+        }>;
+        content: z.ZodUnion<readonly [z.ZodType<AnyPatternConfig, unknown, z.core.$ZodTypeInternals<AnyPatternConfig, unknown>>, z.ZodArray<z.ZodType<AnyPatternConfig, unknown, z.core.$ZodTypeInternals<AnyPatternConfig, unknown>>>]>;
+        props: z.ZodOptional<z.ZodObject<{
+            size: z.ZodOptional<z.ZodEnum<{
+                md: "md";
+                sm: "sm";
+                full: "full";
+                lg: "lg";
+                xl: "xl";
+            }>>;
+            position: z.ZodOptional<z.ZodEnum<{
+                right: "right";
+                center: "center";
+                top: "top";
+                bottom: "bottom";
+                left: "left";
+            }>>;
+            title: z.ZodOptional<z.ZodString>;
+            closable: z.ZodOptional<z.ZodBoolean>;
+            width: z.ZodOptional<z.ZodString>;
+            showProgress: z.ZodOptional<z.ZodBoolean>;
+            step: z.ZodOptional<z.ZodNumber>;
+            totalSteps: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    config: z.ZodOptional<z.ZodType<Readonly<Record<string, ConfigFieldDeclaration>>, Record<string, object>, z.core.$ZodTypeInternals<Readonly<Record<string, ConfigFieldDeclaration>>, Record<string, object>>>>;
+    sourceBehavior: z.ZodOptional<z.ZodObject<{
+        behavior: z.ZodString;
+        alias: z.ZodString;
+        originalName: z.ZodString;
+    }, z.core.$strip>>;
+    sourceDeclaration: z.ZodOptional<z.ZodObject<{
+        traitId: z.ZodString;
+        fingerprint: z.ZodString;
+    }, z.core.$strip>>;
+    sourceEntityDefinition: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        id: z.ZodOptional<z.ZodString & z.ZodType<EntityId, string, z.core.$ZodTypeInternals<EntityId, string>>>;
+        persistence: z.ZodDefault<z.ZodEnum<{
+            persistent: "persistent";
+            runtime: "runtime";
+        }>>;
+        shared: z.ZodOptional<z.ZodBoolean>;
+        identity: z.ZodOptional<z.ZodBoolean>;
+        browser: z.ZodOptional<z.ZodBoolean>;
+        store: z.ZodOptional<z.ZodString>;
+        read_policy: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+        create_policy: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+        update_policy: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+        delete_policy: z.ZodOptional<z.ZodType<SExpr, unknown, z.core.$ZodTypeInternals<SExpr, unknown>>>;
+        access_waivers: z.ZodOptional<z.ZodObject<{
+            read: z.ZodOptional<z.ZodString>;
+            create: z.ZodOptional<z.ZodString>;
+            update: z.ZodOptional<z.ZodString>;
+            delete: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        invariants: z.ZodOptional<z.ZodType<SExpr[], unknown, z.core.$ZodTypeInternals<SExpr[], unknown>>>;
+        indexes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            fields: z.ZodArray<z.ZodString>;
+            orderBy: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        collection: z.ZodOptional<z.ZodString>;
+        fields: z.ZodArray<z.ZodType<EntityField, unknown, z.core.$ZodTypeInternals<EntityField, unknown>>>;
+        instances: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>>;
+        localeInstances: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>>>;
+        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>>;
+            style: z.ZodOptional<z.ZodEnum<{
+                isometric: "isometric";
+                pixel: "pixel";
+                vector: "vector";
+                hd: "hd";
+                "1-bit": "1-bit";
+            }>>;
+            variant: z.ZodOptional<z.ZodString>;
+            dimension: z.ZodOptional<z.ZodEnum<{
+                "2d": "2d";
+                "3d": "3d";
+            }>>;
+            aspect: z.ZodOptional<z.ZodEnum<{
+                "1:1": "1:1";
+                "16:9": "16:9";
+                "5:7": "5:7";
+                "8:1": "8:1";
+                "4:1": "4:1";
+                "5:3": "5:3";
+                "1:2": "1:2";
+            }>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    typeParams: z.ZodOptional<z.ZodArray<z.ZodType<TraitTypeParamDef, unknown, z.core.$ZodTypeInternals<TraitTypeParamDef, unknown>>>>;
+}, z.core.$strip>]>;
+
+export { EventPayloadFieldSchema as F, EventSchema as G, EventScopeSchema as H, GuardSchema as K, ListenSourceSchema as O, OrbitalTraitRefSchema as R, PayloadFieldSchema as U, PayloadTypeWhenSchema as X, REFERENCE_CONFIG_TYPES as Z, RequiredFieldSchema as a0, SECRET_CONFIG_TYPES as a1, SKELETON_VARIANTS as a2, SkeletonNodeSchema as a4, SkeletonShapeSchema as a6, SkeletonSpecSchema as a8, TransitionSchema as aA, configRefEventKnob as aB, getTraitConfig as aC, getTraitName as aD, isCallSiteConfigDeclaration as aE, isCircuitEvent as aF, isConfigFieldSchema as aG, isConfigRedeclaration as aH, isInlineTrait as aI, isReferenceConfigType as aJ, isSecretConfigType as aK, joinEventAddress as aL, maskSecretConfigValues as aM, normalizeCallSiteConfigToValues as aN, normalizeTraitRef as aO, overrideDeclaredKnobs as aP, payloadTypeContainer as aQ, resolveConfigRefEventName as aR, splitEventAddress as aS, SkeletonVariantSchema as aa, StateMachineSchema as ae, StateSchema as af, TickIntervalSchema as ag, TraitConfigSchema as ah, TraitConfigValueSchema as ai, TraitDataEntitySchema as ak, TraitDispatchModeSchema as al, TraitEntityFieldSchema as am, TraitEventContractSchema as an, TraitEventListenerSchema as ao, TraitRefSchema as aq, TraitReferenceSchema as as, TraitSchema as at, TraitTickSchema as av, TraitUIBindingSchema as ax, mergeCallSiteConfigOverrides as m, AwaitRenderSchema as p, CONFIG_REF_EVENT_PATTERN as q, ConfigFieldDeclarationSchema as s, DeclaredTraitConfigSchema as v, DispatchModeSchema as w, EntityFieldContractSchema as y };
+export type { RequiredField as $, AwaitRender as A, EventInput as B, ConfigFieldDeclaration as C, DeclaredTraitConfig as D, EventPayloadField as E, Guard as I, GuardInput as J, InboundDeclaration as L, InboundVerification as M, ListenSource as N, PayloadField as P, OrbitalTraitRef as Q, SkeletonNode as S, TraitEventListener as T, PayloadTypeContainer as V, PayloadTypeWhen as W, PresentationType as Y, ReferenceConfigType as _, TraitReference as a, SecretConfigType as a3, SkeletonShape as a5, SkeletonSpec as a7, SkeletonVariant as a9, State as ab, StateInput as ac, StateMachineInput as ad, TraitDataEntity as aj, TraitInput as ap, TraitReferenceInput as ar, TraitTick as au, TraitUIBinding as aw, Transition as ay, TransitionInput as az, TraitConfigValue as b, Trait as c, TraitConfig as d, TraitConfigObject as e, TraitRef as f, EventScope as g, TraitDispatchMode as h, DispatchMode as i, TraitEntityField as j, TraitTypeParamDef as k, CallSiteConfig as l, StateMachine as n, TraitEventContract as o, CallSiteConfigEntry as r, ConfigFieldItemsDeclaration as t, ConfigRefEventError as u, EntityFieldContract as x, Event as z };