@almadar/ui 5.111.0 → 5.112.0

package/dist/renderer/index.d.ts

@@ -1,28 +1,343 @@
+import { M as MappedPattern, C as ClientEffect, q as ClientEffectExecutorConfig, r as NotifyOptions, D as DataContext, s as DataResolution, S as SlotDefinition } from '../offline-executor-aRuNznZx.js';
+export { E as EventResponse, N as NavigationContextValue, b as NavigationProvider, c as NavigationProviderProps, d as NavigationState, O as OfflineExecutor, t as OfflineExecutorConfig, v as OfflineExecutorState, P as PendingSyncEffect, w as SlotType, a as UseOfflineExecutorOptions, U as UseOfflineExecutorResult, x as createOfflineExecutor, e as extractRouteParams, f as findPageByName, g as findPageByPath, h as getAllPages, i as getDefaultPage, m as matchPath, p as pathMatches, u as useActivePage, j as useInitPayload, k as useNavigateTo, l as useNavigation, n as useNavigationId, o as useNavigationState, y as useOfflineExecutor } from '../offline-executor-aRuNznZx.js';
+import { PatternPropDef } from '@almadar/core/patterns';
+import { PatternConfig, FieldValue, EntityRow, UISlot } from '@almadar/core';
+export { PatternConfig, UISlot } from '@almadar/core';
+import * as React from 'react';
+
 /**
- * Shared Renderer Module
+ * Pattern Resolver
  *
- * Provides unified rendering logic for both Builder preview and compiled shells.
- * This is the core of the runtime unification - both systems use this same code.
+ * Resolves pattern configurations to component information.
+ * Uses the central pattern registry and component mapping from orbital-shared/patterns/.
  *
- * Key components:
- * - Types: Shared type definitions for effects, patterns, responses
- * - Pattern Resolver: Pattern → Component resolution
- * - Client Effect Executor: Execute clientEffects from server
- * - useClientEffects: React hook for effect execution
- * - Data Resolver: Entity data resolution with filtering
- * - Slot Definitions: Inline vs portal slot configuration
+ * This is the shared logic used by both Builder's PatternRenderer and
+ * the compiled shell's UISlotRenderer.
  *
  * @packageDocumentation
  */
-export type { ClientEffect, NotifyOptions, ClientEffectExecutorConfig, PatternConfig, MappedPattern, EventResponse, UISlot, SlotType, SlotDefinition, DataContext, DataResolution, } from '../types/renderer-types';
-export { resolvePattern, isKnownPattern, getKnownPatterns, getPatternsByCategory, getPatternMapping, getPatternDefinition, initializePatternResolver, setComponentMapping, setPatternRegistry, } from '../lib/pattern-resolver';
-export { executeClientEffects, parseClientEffect, parseClientEffects, getRenderUIEffects, getNotifyEffects, } from '../lib/client-effect-executor';
-export { useClientEffects, useClientEffectConfig, useClientEffectConfigOptional, ClientEffectConfigProvider, ClientEffectConfigContext, } from '../hooks/useClientEffects';
-export type { UseClientEffectsOptions, UseClientEffectsResult, } from '../hooks/useClientEffects';
-export { resolveEntityData, resolveEntityDataWithQuery, resolveEntityById, hasEntities, } from '../lib/data-resolver';
-export { SLOT_DEFINITIONS, getSlotDefinition, isPortalSlot, getInlineSlots, ALL_SLOTS, } from '../lib/slot-definitions';
-export { OfflineExecutor, createOfflineExecutor, useOfflineExecutor, } from '../lib/offline-executor';
-export type { PendingSyncEffect, OfflineExecutorConfig, OfflineExecutorState, UseOfflineExecutorOptions, UseOfflineExecutorResult, } from '../lib/offline-executor';
-export { NavigationProvider, useNavigation, useNavigateTo, useNavigationState, useInitPayload, useActivePage, useNavigationId, matchPath, extractRouteParams, pathMatches, findPageByPath, findPageByName, getDefaultPage, getAllPages, } from '../providers/navigation';
-export type { NavigationState, NavigationContextValue, NavigationProviderProps, } from '../providers/navigation';
-export { initializePatterns } from '../lib/init';
+
+/**
+ * Component mapping entry from component-mapping.json
+ */
+interface ComponentMappingEntry {
+    component: string;
+    importPath: string;
+    category: string;
+    deprecated?: boolean;
+    replacedBy?: string;
+}
+/**
+ * Pattern definition from registry.json
+ */
+interface PatternDefinition {
+    type: string;
+    category: string;
+    description: string;
+    propsSchema?: Record<string, PatternPropDef>;
+}
+/**
+ * Initialize the pattern resolver with mappings.
+ * Called at app startup with data from JSON files.
+ */
+declare function initializePatternResolver(config: {
+    componentMapping: Record<string, ComponentMappingEntry>;
+    patternRegistry: Record<string, PatternDefinition>;
+}): void;
+/**
+ * Set component mapping (alternative to full initialization).
+ */
+declare function setComponentMapping(mapping: Record<string, ComponentMappingEntry>): void;
+/**
+ * Set pattern registry (alternative to full initialization).
+ */
+declare function setPatternRegistry(registry: Record<string, PatternDefinition>): void;
+/**
+ * Resolve a pattern configuration to component information.
+ *
+ * @param config - Pattern configuration from render-ui effect
+ * @returns Resolved pattern with component name, import path, and validated props
+ * @throws Error if pattern type is unknown
+ *
+ * @example
+ * ```typescript
+ * const resolved = resolvePattern({
+ *   type: 'entity-table',
+ *   entity: 'Task',
+ *   columns: ['title', 'status']
+ * });
+ * // resolved.component === 'DataTable'
+ * // resolved.importPath === '@/components/organisms/DataTable'
+ * ```
+ */
+declare function resolvePattern(config: PatternConfig): MappedPattern;
+/**
+ * Check if a pattern type is known.
+ */
+declare function isKnownPattern(type: string): boolean;
+/**
+ * Get all known pattern types.
+ */
+declare function getKnownPatterns(): string[];
+/**
+ * Get patterns by category.
+ */
+declare function getPatternsByCategory(category: string): string[];
+/**
+ * Get the component mapping for a pattern type.
+ */
+declare function getPatternMapping(type: string): ComponentMappingEntry | undefined;
+/**
+ * Get the pattern definition from the registry.
+ */
+declare function getPatternDefinition(type: string): PatternDefinition | undefined;
+
+/**
+ * Client Effect Executor
+ *
+ * Executes client effects returned from the server.
+ * This is the core of the dual execution model - the server processes
+ * events and returns client effects, which this module executes.
+ *
+ * Used by both Builder preview and compiled shells.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Execute an array of client effects.
+ *
+ * Effects are executed sequentially in order.
+ * Errors in one effect don't prevent subsequent effects from executing.
+ *
+ * @param effects - Array of client effects to execute
+ * @param config - Configuration providing implementations for each effect type
+ *
+ * @example
+ * ```typescript
+ * executeClientEffects(
+ *   [
+ *     ['render-ui', 'main', { type: 'entity-table', entity: 'Task' }],
+ *     ['notify', 'Tasks loaded!', { type: 'success' }]
+ *   ],
+ *   {
+ *     renderToSlot: (slot, pattern) => slotManager.render(slot, pattern),
+ *     navigate: (path) => router.push(path),
+ *     notify: (message, opts) => toast.show(message, opts),
+ *     eventBus: { emit: (event, payload) => bus.emit(event, payload) }
+ *   }
+ * );
+ * ```
+ */
+declare function executeClientEffects(effects: ClientEffect[], config: ClientEffectExecutorConfig): void;
+/**
+ * Parse a raw effect array into a typed ClientEffect.
+ * Handles unknown effect formats gracefully.
+ */
+declare function parseClientEffect(raw: FieldValue[]): ClientEffect | null;
+/**
+ * Parse an array of raw effects into typed ClientEffects.
+ * Filters out invalid effects.
+ */
+declare function parseClientEffects(raw: FieldValue[] | undefined): ClientEffect[];
+/**
+ * Get all render-ui effects.
+ */
+declare function getRenderUIEffects(effects: ClientEffect[]): Array<['render-ui', string, PatternConfig | null]>;
+/**
+ * Get all notify effects.
+ */
+declare function getNotifyEffects(effects: ClientEffect[]): Array<['notify', string, NotifyOptions?]>;
+
+/**
+ * Options for the useClientEffects hook
+ */
+interface UseClientEffectsOptions extends ClientEffectExecutorConfig {
+    /**
+     * Whether to execute effects. Defaults to true.
+     * Set to false to temporarily disable effect execution.
+     */
+    enabled?: boolean;
+    /**
+     * Debug mode - logs effect execution details.
+     */
+    debug?: boolean;
+}
+/**
+ * Result of useClientEffects hook
+ */
+interface UseClientEffectsResult {
+    /**
+     * Number of effects executed in the last batch.
+     */
+    executedCount: number;
+    /**
+     * Whether effects are currently being executed.
+     */
+    executing: boolean;
+    /**
+     * Manually trigger effect execution.
+     * Useful for imperative control.
+     */
+    execute: (effects: ClientEffect[]) => void;
+}
+/**
+ * Execute client effects from server response.
+ *
+ * This hook automatically executes effects when they change,
+ * tracking which effects have been executed to prevent duplicates.
+ *
+ * @param effects - Array of client effects to execute (from server response)
+ * @param options - Configuration including effect implementations
+ * @returns Hook result with execution state and manual trigger
+ *
+ * @example
+ * ```typescript
+ * function useMyTrait() {
+ *   const [state, setState] = useState({ pendingEffects: [] });
+ *   const effectConfig = useClientEffectConfig();
+ *
+ *   useClientEffects(state.pendingEffects, {
+ *     ...effectConfig,
+ *     onComplete: () => setState(s => ({ ...s, pendingEffects: [] }))
+ *   });
+ *
+ *   // ...
+ * }
+ * ```
+ */
+declare function useClientEffects(effects: ClientEffect[] | undefined, options: UseClientEffectsOptions): UseClientEffectsResult;
+declare const ClientEffectConfigContext: React.Context<ClientEffectExecutorConfig | null>;
+/**
+ * Provider for client effect configuration.
+ */
+declare const ClientEffectConfigProvider: React.Provider<ClientEffectExecutorConfig | null>;
+/**
+ * Hook to get the client effect configuration from context.
+ *
+ * @throws Error if used outside of ClientEffectConfigProvider
+ *
+ * @example
+ * ```typescript
+ * function MyTraitHook() {
+ *   const effectConfig = useClientEffectConfig();
+ *
+ *   useClientEffects(pendingEffects, {
+ *     ...effectConfig,
+ *     onComplete: () => clearPendingEffects()
+ *   });
+ * }
+ * ```
+ */
+declare function useClientEffectConfig(): ClientEffectExecutorConfig;
+/**
+ * Hook to get client effect configuration, returning null if not available.
+ * Use this for optional integration where effects may not be configured.
+ */
+declare function useClientEffectConfigOptional(): ClientEffectExecutorConfig | null;
+
+/**
+ * Data Resolver
+ *
+ * Resolves entity data for pattern rendering.
+ * Supports multiple data sources with priority:
+ * 1. Server-provided data (from EventResponse.data)
+ * 2. Entity store (Builder in-memory mock data)
+ * 3. Empty array (fallback)
+ *
+ * Used by both Builder's PatternRenderer and compiled shell's UISlotRenderer.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Resolve entity data from available sources.
+ *
+ * Priority:
+ * 1. fetchedData (from server response) - highest priority
+ * 2. entityStore (Builder mock data)
+ * 3. Empty array (fallback)
+ *
+ * @param entityName - Name of the entity to resolve data for
+ * @param context - Data context with available sources
+ * @returns Resolved data with loading state
+ *
+ * @example
+ * ```typescript
+ * const { data, loading } = resolveEntityData('Task', {
+ *   fetchedData: response.data,
+ *   entityStore: mockStore
+ * });
+ * ```
+ */
+declare function resolveEntityData(entityName: string, context: DataContext): DataResolution;
+/**
+ * Resolve entity data with query filtering.
+ *
+ * Applies query singleton filters if available.
+ *
+ * @param entityName - Name of the entity
+ * @param queryRef - Optional query reference for filtering
+ * @param context - Data context
+ * @returns Filtered resolved data
+ */
+declare function resolveEntityDataWithQuery(entityName: string, queryRef: string | undefined, context: DataContext): DataResolution;
+/**
+ * Get a single entity record by ID.
+ */
+declare function resolveEntityById(entityName: string, id: string | number, context: DataContext): EntityRow | null;
+/**
+ * Check if any entities exist for a given entity name.
+ */
+declare function hasEntities(entityName: string, context: DataContext): boolean;
+
+/**
+ * Slot Definitions
+ *
+ * Defines the available UI slots and their rendering behavior.
+ * Slots are either inline (rendered in the component tree) or
+ * portal (rendered to document.body via React Portal).
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Definitions for all available UI slots.
+ *
+ * Inline slots render within the component hierarchy.
+ * Portal slots render to document.body, breaking out of overflow containers.
+ */
+declare const SLOT_DEFINITIONS: Partial<Record<UISlot, SlotDefinition>> & Record<'main' | 'sidebar' | 'modal' | 'drawer' | 'overlay' | 'center' | 'toast' | 'hud-top' | 'hud-bottom' | 'floating', SlotDefinition>;
+/**
+ * Get the slot definition for a slot name.
+ */
+declare function getSlotDefinition(slot: UISlot): SlotDefinition | undefined;
+/**
+ * Check if a slot is a portal slot.
+ */
+declare function isPortalSlot(slot: string): boolean;
+/**
+ * Get all inline slots.
+ */
+declare function getInlineSlots(): UISlot[];
+/**
+ * All valid slot names.
+ */
+declare const ALL_SLOTS: UISlot[];
+
+/**
+ * Pattern Resolver Initialization
+ *
+ * Loads pattern registry and component mapping from @almadar/core/patterns
+ * and initializes the pattern resolver at app startup.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Initialize the pattern resolver with shared pattern data.
+ * Must be called once at app startup before any pattern rendering.
+ * @returns The number of patterns initialized
+ */
+declare function initializePatterns(): number;
+
+export { ALL_SLOTS, ClientEffect, ClientEffectConfigContext, ClientEffectConfigProvider, ClientEffectExecutorConfig, DataContext, DataResolution, MappedPattern, NotifyOptions, SLOT_DEFINITIONS, SlotDefinition, type UseClientEffectsOptions, type UseClientEffectsResult, executeClientEffects, getInlineSlots, getKnownPatterns, getNotifyEffects, getPatternDefinition, getPatternMapping, getPatternsByCategory, getRenderUIEffects, getSlotDefinition, hasEntities, initializePatternResolver, initializePatterns, isKnownPattern, isPortalSlot, parseClientEffect, parseClientEffects, resolveEntityById, resolveEntityData, resolveEntityDataWithQuery, resolvePattern, setComponentMapping, setPatternRegistry, useClientEffectConfig, useClientEffectConfigOptional, useClientEffects };

package/dist/renderer/index.js

@@ -1,7 +1,7 @@
 import { createLogger } from '@almadar/logger';
 import { createContext, useRef, useCallback, useEffect, useContext, useState } from 'react';
 export { NavigationProvider, extractRouteParams, findPageByName, findPageByPath, getAllPages, getDefaultPage, matchPath, pathMatches, useActivePage, useInitPayload, useNavigateTo, useNavigation, useNavigationId, useNavigationState } from '@almadar/ui/providers';
-import { componentMapping as componentMapping$1, patternsRegistry } from '@almadar/patterns';
+import { componentMapping as componentMapping$1, patternsRegistry } from '@almadar/core/patterns';
 
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;

package/dist/runtime/index.cjs

@@ -41,7 +41,7 @@ var core$1 = require('@dnd-kit/core');
 var sortable = require('@dnd-kit/sortable');
 var utilities = require('@dnd-kit/utilities');
 var react = require('@xyflow/react');
-var patterns = require('@almadar/patterns');
+var patterns = require('@almadar/core/patterns');
 var runtime = require('@almadar/runtime');
 var OrbitalServerRuntime = require('@almadar/runtime/OrbitalServerRuntime');
 
@@ -9273,8 +9273,12 @@ var init_MiniMap = __esm({
     MiniMap.displayName = "MiniMap";
   }
 });
-function useCamera() {
-  const cameraRef = React81.useRef({ x: 0, y: 0, zoom: 1 });
+function useCamera(initial) {
+  const cameraRef = React81.useRef({
+    x: initial?.x ?? 0,
+    y: initial?.y ?? 0,
+    zoom: initial?.zoom ?? 1
+  });
   const targetCameraRef = React81.useRef(null);
   const isDraggingRef = React81.useRef(false);
   const dragDistanceRef = React81.useRef(0);
@@ -9843,9 +9847,17 @@ function Canvas2D({
   scale = 0.4,
   showMinimap = true,
   followTarget,
+  cameraPos,
   bgColor
 }) {
+  const layerSummaries = drawables?.map((d) => {
+    if (!d || typeof d !== "object") return d;
+    const rec = d;
+    return { type: rec.type, itemsLen: Array.isArray(rec.items) ? rec.items.length : void 0, firstItem: Array.isArray(rec.items) ? rec.items[0] : void 0 };
+  });
+  console.error("[debug:Canvas2D] " + JSON.stringify({ projection, scale, cameraMode: camera, cameraPos, drawablesCount: drawables?.length, layerSummaries }));
   const backgroundImage = normalizeBackdrop(backgroundImageRaw);
+  const instanceId = React81.useMemo(() => Math.random().toString(36).slice(2, 8), []);
   const isFree = projection === "free";
   const squareGrid = projection === "flat" || isFree || projection === "side";
   const layout = projection === "side" ? "free" : projection;
@@ -9927,7 +9939,7 @@ function Canvas2D({
     zoomAtPoint,
     screenToWorld,
     lerpToTarget
-  } = useCamera();
+  } = useCamera({ zoom: scale });
   const [atlasVersion, setAtlasVersion] = React81.useState(0);
   const bumpAtlas = React81.useCallback(() => setAtlasVersion((v) => v + 1), []);
   const miniMapTiles = React81.useMemo(() => {
@@ -9973,6 +9985,14 @@ function Canvas2D({
     }
     if (!drawables || drawables.length === 0) return;
     const cam = cameraRef.current;
+    if (cameraPos && dragDistance() === 0) {
+      const p = projector.anchorPoint(cameraPos, "center");
+      cam.x = p.x - viewportSize.width / 2;
+      cam.y = p.y - viewportSize.height / 2;
+    }
+    const containerRect = containerRef.current?.getBoundingClientRect();
+    const canvasRect = canvas.getBoundingClientRect();
+    console.error("[debug:Canvas2D:draw:" + instanceId + "] " + JSON.stringify({ viewportSize, baseOffsetX, cam: { x: cam.x, y: cam.y, zoom: cam.zoom }, cameraPos, containerRect: containerRect ? { width: containerRect.width, height: containerRect.height } : null, canvasRect: canvasRect ? { width: canvasRect.width, height: canvasRect.height } : null }));
     const painter = createWebPainter(ctx, bumpAtlas);
     painter.save();
     painter.translate(viewportSize.width / 2, viewportSize.height / 2);
@@ -10243,6 +10263,7 @@ function Canvas({
   keyMap,
   keyUpMap
 }) {
+  console.error("[debug:Canvas] " + JSON.stringify({ mode, drawablesCount: drawables?.length, projection, camera }));
   const zoom = camera?.zoom;
   if (mode === "3d") {
     const props3d = {
@@ -10282,6 +10303,7 @@ function Canvas({
       camera: to2DCamera(camera?.mode),
       ...zoom !== void 0 ? { scale: zoom } : {},
       ...camera?.target !== void 0 ? { followTarget: camera.target } : {},
+      ...camera?.pos !== void 0 ? { cameraPos: camera.pos } : {},
       showMinimap,
       backgroundImage,
       ...backgroundColor !== void 0 ? { bgColor: backgroundColor } : {},
@@ -43696,7 +43718,7 @@ function SlotContentRenderer({
     const childrenConfig = content.props.children;
     const isSingleChild = typeof childrenConfig === "string" || typeof childrenConfig === "object" && childrenConfig !== null && !Array.isArray(childrenConfig) && "type" in childrenConfig;
     const hasChildren = PATTERNS_WITH_CHILDREN.has(content.pattern) || Array.isArray(childrenConfig) && childrenConfig.length > 0 || isSingleChild;
-    const isDrawHost = patterns.getPatternDefinition(content.pattern)?.drawHost === true;
+    const isDrawHost = patterns.isDrawHostPattern(content.pattern);
     const myPath = patternPath ?? "root";
     const renderedChildren = hasChildren && !isDrawHost ? renderPatternChildren(childrenConfig, onDismiss, content.id, myPath, content.sourceTrait, {
       slot: content.slot,
@@ -44267,6 +44289,14 @@ function effectsCallOp(effects, ops) {
   }
   return false;
 }
+function classifySharedTick(tick) {
+  const writes = effectsCallOp(tick.effects, SHARED_ENTITY_WRITE_OPS);
+  const renders = effectsCallOp(tick.effects, SHARED_ENTITY_RENDER_OPS);
+  if (writes && renders) return "both";
+  if (writes) return "writer";
+  if (renders) return "renderer";
+  return "neither";
+}
 function createSharedEntityWriter(binding, tick, traitStatesRef, emit) {
   return (scratch) => {
     const traitName = binding.trait.name;
@@ -44276,7 +44306,7 @@ function createSharedEntityWriter(binding, tick, traitStatesRef, emit) {
     const writes = [];
     const ctx = evaluator.createMinimalContext(scratchEntity, {}, currentState);
     const declaredDefaults = runtime.collectDeclaredConfigDefaults(binding.trait);
-    const callSiteConfig = binding.config;
+    const callSiteConfig = getBindingConfig(binding);
     if (declaredDefaults || callSiteConfig) {
       ctx.config = { ...declaredDefaults ?? {}, ...callSiteConfig ?? {} };
     }
@@ -44298,7 +44328,25 @@ function createSharedEntityWriter(binding, tick, traitStatesRef, emit) {
     return writes;
   };
 }
+function getBindingConfig(binding) {
+  const raw = binding.config;
+  const normalized = runtime.normalizeCallSiteConfigToValues(raw);
+  console.log("[debug:getBindingConfig]", binding.trait.name, "raw keys=", raw ? Object.keys(raw) : "undefined", "has tiles=", raw ? "tiles" in raw : false);
+  return normalized;
+}
+function evalFieldDefault(value) {
+  if (!Array.isArray(value) || value.length === 0) return value;
+  const head = value[0];
+  const isSExpr = typeof head === "string" && (head.includes("/") || head === "let" || head === "if" || head === "lambda");
+  if (!isSExpr) return value;
+  try {
+    return evaluator.evaluate(value, evaluator.createMinimalContext({}, {}, ""));
+  } catch {
+    return value;
+  }
+}
 function useTraitStateMachine(traitBindings, uiSlots, options) {
+  console.log("[debug:useTraitStateMachine] start, traitBindings count=", traitBindings.length, "names=", traitBindings.map((b) => b.trait.name).join(","));
   const eventBus = useEventBus();
   const { entities } = providers.useEntitySchema();
   const traitConfigsByName = options?.traitConfigsByName;
@@ -44318,7 +44366,11 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
         let defaults;
         for (const field of entityDef.fields) {
           if (field.default !== void 0) {
-            (defaults ?? (defaults = {}))[field.name] = field.default;
+            const evaluated = evalFieldDefault(field.default);
+            if (field.name === "tiles") {
+              console.log(`[debug:seed] ${linkedEntityName}.tiles seed type=`, typeof evaluated, Array.isArray(evaluated) ? "len=" + evaluated?.length : "", "head=", Array.isArray(evaluated) && evaluated.length > 0 ? JSON.stringify(evaluated[0]).slice(0, 80) : "n/a");
+            }
+            (defaults ?? (defaults = {}))[field.name] = evaluated;
           }
         }
         group = { storeKey, entityName: linkedEntityName, writerBindings: [], renderBindings: [], defaults };
@@ -44331,7 +44383,10 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
     return groups;
   }, [traitBindings, entities, orbitalsByTrait]);
   for (const group of sharedGroups.values()) {
-    if (group.defaults) sharedEntityStore.seed(group.storeKey, group.defaults);
+    if (group.defaults) {
+      sharedEntityStore.seed(group.storeKey, group.defaults);
+      console.log("[debug:shared-seed]", group.storeKey, "writers=", group.writerBindings.map((b) => b.trait.name).join(","), "renderers=", group.renderBindings.map((b) => b.trait.name).join(","), "defaults.tiles=", Array.isArray(group.defaults.tiles) ? group.defaults.tiles.length : group.defaults.tiles);
+    }
   }
   const sharedKeyByTraitNameRef = React81.useRef(/* @__PURE__ */ new Map());
   React81.useEffect(() => {
@@ -44341,12 +44396,13 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
       for (const binding of group.renderBindings) map.set(binding.trait.name, group.storeKey);
     }
     sharedKeyByTraitNameRef.current = map;
+    console.log("[debug:shared-map]", Array.from(map.entries()).map(([k, v]) => `${k}->${v}`).join(","));
   }, [sharedGroups]);
   const manager = React81.useMemo(() => {
     const traitDefs = traitBindings.map(toTraitDefinition);
     const m = new runtime.StateMachineManager(traitDefs);
     for (const binding of traitBindings) {
-      const cfg = binding.config ?? traitConfigsByName?.[binding.trait.name];
+      const cfg = getBindingConfig(binding) ?? traitConfigsByName?.[binding.trait.name];
       if (cfg !== void 0) {
         m.setTraitConfig(binding.trait.name, cfg);
       }
@@ -44529,6 +44585,9 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
     const linkedEntity = binding.linkedEntity || "";
     const entityId = payload?.entityId;
     const sharedKey = sharedKeyByTraitNameRef.current.get(traitName);
+    if (traitName === "Hero" || traitName === "Authority") {
+      console.log(`[debug:executeTransitionEffects] ${traitName} sharedKey=`, sharedKey, "store tiles=", sharedKey ? sharedEntityStore.getSnapshot(sharedKey).tiles?.length : "n/a");
+    }
     let liveEntity;
     if (sharedKey !== void 0) {
       liveEntity = { ...sharedEntityStore.getSnapshot(sharedKey) };
@@ -44552,6 +44611,13 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
       eventBus,
       slotSetter: {
         addPattern: (slot, pattern, props) => {
+          if (traitName === "Hero" && slot === "main" && props && typeof props === "object") {
+            const canvasChild = Array.isArray(props.children) ? props.children[0] : null;
+            const grandChildren = canvasChild && typeof canvasChild === "object" ? canvasChild.children : null;
+            const firstLayer = Array.isArray(grandChildren) && grandChildren.length > 0 ? grandChildren[0] : null;
+            const firstLayerItems = firstLayer && typeof firstLayer === "object" ? firstLayer.items : null;
+            console.log(`[debug:render-ui] ${traitName} slot=${slot} canvasChild=`, canvasChild ? canvasChild.type : "none", "firstLayerItems=", Array.isArray(firstLayerItems) ? firstLayerItems.length : firstLayerItems);
+          }
           const existing = pendingSlots.get(slot) || [];
           existing.push({ pattern, props: props || {} });
           pendingSlots.set(slot, existing);
@@ -44583,7 +44649,7 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
         state: previousState
       };
       const sharedDeclared = runtime.collectDeclaredConfigDefaults(binding.trait);
-      const sharedCallSite = binding.config;
+      const sharedCallSite = getBindingConfig(binding);
       if (sharedDeclared || sharedCallSite) {
         sharedBindings.config = {
           ...sharedDeclared ?? {},
@@ -44634,13 +44700,16 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
       state: previousState
     };
     const declaredDefaults = runtime.collectDeclaredConfigDefaults(binding.trait);
-    const callSiteConfig = binding.config;
+    const callSiteConfig = getBindingConfig(binding);
     if (declaredDefaults || callSiteConfig) {
       bindingCtx.config = {
         ...declaredDefaults ?? {},
         ...callSiteConfig ?? {}
       };
     }
+    if (traitName === "Authority" || traitName === "Hero") {
+      console.log(`[debug:executeTransitionEffects] ${traitName} config tiles type=`, typeof bindingCtx.config?.tiles, Array.isArray(bindingCtx.config?.tiles) ? "len=" + bindingCtx.config?.tiles?.length : "", "keys=", bindingCtx.config ? Object.keys(bindingCtx.config) : "none");
+    }
     const effectContext = {
       traitName,
       state: previousState,
@@ -44657,9 +44726,15 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
         baseEmit(event, eventPayload, source);
       }
     };
+    if (traitName === "Hero") {
+      console.log(`[debug:executeTransitionEffects] ${traitName} effects count=${effects.length} hasRenderUI=${typeof handlers.renderUI === "function"} effect heads=${effects.map((e) => Array.isArray(e) ? String(e[0]) : "??").join(",")}`);
+    }
     const executor = new runtime.EffectExecutor({ handlers: trackingHandlers, bindings: bindingCtx, context: effectContext });
     try {
       await executor.executeAll(effects);
+      if (traitName === "Authority" || traitName === "Hero") {
+        console.log(`[debug:executeTransitionEffects] ${traitName} after executeAll liveEntity.tiles type=`, typeof liveEntity.tiles, Array.isArray(liveEntity.tiles) ? "len=" + liveEntity.tiles?.length : "", "firstTilePos=", Array.isArray(liveEntity.tiles) && liveEntity.tiles.length > 0 ? JSON.stringify(liveEntity.tiles[0]).slice(0, 120) : "n/a");
+      }
       if (sharedKey !== void 0) {
         sharedEntityStore.commit(sharedKey, liveEntity);
       }
@@ -44710,8 +44785,9 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
         payload: {},
         state: currentState
       };
-      if (binding.config) {
-        guardCtx.config = binding.config;
+      const bindingCfg = getBindingConfig(binding);
+      if (bindingCfg) {
+        guardCtx.config = bindingCfg;
       }
       const passed = evaluator.evaluateGuard(
         tick.guard,
@@ -44738,12 +44814,14 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
   }, [eventBus]);
   React81.useEffect(() => {
     const scheduler = runtime.createTickScheduler();
-    const writerTraitNames = /* @__PURE__ */ new Set();
+    const pureWriterTickKeys = /* @__PURE__ */ new Set();
     for (const group of sharedGroups.values()) {
       const ticksByInterval = /* @__PURE__ */ new Map();
       for (const binding of group.writerBindings) {
-        writerTraitNames.add(binding.trait.name);
         for (const tick of binding.trait.ticks ?? []) {
+          const classification = classifySharedTick(tick);
+          if (classification !== "writer") continue;
+          pureWriterTickKeys.add(`${binding.trait.name}::${tick.name}`);
           const intervalKey = String(tick.interval);
           const entries = ticksByInterval.get(intervalKey) ?? [];
           entries.push({ binding, tick });
@@ -44770,8 +44848,11 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
       }
     }
     for (const binding of traitBindings) {
-      if (writerTraitNames.has(binding.trait.name)) continue;
       for (const tick of binding.trait.ticks ?? []) {
+        const sharedKey = sharedKeyByTraitNameRef.current.get(binding.trait.name);
+        if (sharedKey !== void 0 && pureWriterTickKeys.has(`${binding.trait.name}::${tick.name}`)) {
+          continue;
+        }
         if (tick.interval === "frame") {
           scheduler.add(0, () => runTickEffects(tick, binding));
         } else if (typeof tick.interval === "number") {