@almadar/std 1.0.0

package/dist/behaviors/registry.js

@@ -0,0 +1,4166 @@
+// behaviors/types.ts
+function getBehaviorMetadata(behavior) {
+  const sm = behavior.stateMachine;
+  const states = (sm?.states || []).map(
+    (s) => typeof s === "string" ? s : s.name
+  );
+  const events = (sm?.events || []).map(
+    (e) => typeof e === "string" ? e : e.key
+  );
+  return {
+    name: behavior.name,
+    category: behavior.category,
+    description: behavior.description || "",
+    suggestedFor: behavior.suggestedFor || [],
+    states,
+    events,
+    tickCount: behavior.ticks?.length || 0,
+    transitionCount: sm?.transitions?.length || 0,
+    hasDataEntities: (behavior.dataEntities?.length || 0) > 0
+  };
+}
+
+// behaviors/ui-interaction.ts
+var LIST_BEHAVIOR = {
+  name: "std/List",
+  category: "ui-interaction",
+  description: "Entity list management with CRUD operations",
+  suggestedFor: [
+    "Entity listing pages",
+    "Admin panels",
+    "Data management screens",
+    "Table views with inline actions"
+  ],
+  dataEntities: [
+    {
+      name: "ListState",
+      runtime: true,
+      singleton: true,
+      fields: [
+        { name: "selectedId", type: "string", default: null }
+      ]
+    }
+  ],
+  stateMachine: {
+    initial: "Browsing",
+    states: [
+      { name: "Browsing", isInitial: true },
+      { name: "Creating" },
+      { name: "Viewing" },
+      { name: "Editing" },
+      { name: "Deleting" }
+    ],
+    events: [
+      { key: "INIT" },
+      { key: "CREATE" },
+      { key: "VIEW" },
+      { key: "EDIT" },
+      { key: "DELETE" },
+      { key: "CONFIRM_DELETE" },
+      { key: "CANCEL" },
+      { key: "SAVE" }
+    ],
+    transitions: [
+      // INIT: Self-loop on Browsing that renders the list UI
+      {
+        from: "Browsing",
+        to: "Browsing",
+        event: "INIT",
+        effects: [
+          ["render-ui", "main", {
+            type: "page-header",
+            title: "@config.title",
+            actions: [{ label: "Create", event: "CREATE", variant: "primary" }]
+          }],
+          ["render-ui", "main", {
+            type: "entity-table",
+            entity: "@config.entity",
+            columns: "@config.columns",
+            itemActions: [
+              { label: "View", event: "VIEW", placement: "row" },
+              { label: "Edit", event: "EDIT", placement: "row" },
+              { label: "Delete", event: "DELETE", variant: "danger", placement: "row" }
+            ]
+          }]
+        ]
+      },
+      {
+        from: "Browsing",
+        to: "Creating",
+        event: "CREATE",
+        effects: [
+          ["render-ui", "modal", {
+            type: "form-section",
+            entity: "@config.entity",
+            mode: "create",
+            submitEvent: "SAVE",
+            cancelEvent: "CANCEL"
+          }]
+        ]
+      },
+      {
+        from: "Browsing",
+        to: "Viewing",
+        event: "VIEW",
+        effects: [
+          ["set", "@entity.selectedId", "@payload.id"],
+          ["render-ui", "drawer", {
+            type: "entity-detail",
+            entity: "@config.entity",
+            id: "@payload.id",
+            actions: [
+              { label: "Edit", event: "EDIT" },
+              { label: "Close", event: "CANCEL" }
+            ]
+          }]
+        ]
+      },
+      {
+        from: "Browsing",
+        to: "Editing",
+        event: "EDIT",
+        effects: [
+          ["set", "@entity.selectedId", "@payload.id"],
+          ["render-ui", "drawer", {
+            type: "form-section",
+            entity: "@config.entity",
+            id: "@payload.id",
+            mode: "edit",
+            submitEvent: "SAVE",
+            cancelEvent: "CANCEL"
+          }]
+        ]
+      },
+      {
+        from: "Viewing",
+        to: "Editing",
+        event: "EDIT",
+        effects: [
+          ["render-ui", "drawer", {
+            type: "form-section",
+            entity: "@config.entity",
+            id: "@entity.selectedId",
+            mode: "edit",
+            submitEvent: "SAVE",
+            cancelEvent: "CANCEL"
+          }]
+        ]
+      },
+      {
+        from: "Browsing",
+        to: "Deleting",
+        event: "DELETE",
+        effects: [
+          ["set", "@entity.selectedId", "@payload.id"],
+          ["render-ui", "modal", {
+            type: "confirmation",
+            title: "Delete Confirmation",
+            message: "Are you sure you want to delete this item?",
+            confirmLabel: "Delete",
+            confirmVariant: "danger"
+          }]
+        ]
+      },
+      {
+        from: "Creating",
+        to: "Browsing",
+        event: "SAVE",
+        effects: [
+          ["persist", "create", "@config.entity", "@payload.data"],
+          ["render-ui", "modal", null],
+          ["notify", { type: "success", message: "Created successfully" }],
+          ["emit", "INIT"]
+        ]
+      },
+      {
+        from: "Editing",
+        to: "Browsing",
+        event: "SAVE",
+        effects: [
+          ["persist", "update", "@config.entity", "@payload.data"],
+          ["render-ui", "drawer", null],
+          ["notify", { type: "success", message: "Updated successfully" }],
+          ["emit", "INIT"]
+        ]
+      },
+      {
+        from: "Deleting",
+        to: "Browsing",
+        event: "CONFIRM_DELETE",
+        effects: [
+          ["persist", "delete", "@config.entity", "@entity.selectedId"],
+          ["render-ui", "modal", null],
+          ["notify", { type: "success", message: "Deleted successfully" }],
+          ["emit", "INIT"]
+        ]
+      },
+      {
+        from: "Creating",
+        to: "Browsing",
+        event: "CANCEL",
+        effects: [
+          ["render-ui", "modal", null]
+        ]
+      },
+      {
+        from: "Viewing",
+        to: "Browsing",
+        event: "CANCEL",
+        effects: [
+          ["render-ui", "drawer", null]
+        ]
+      },
+      {
+        from: "Editing",
+        to: "Browsing",
+        event: "CANCEL",
+        effects: [
+          ["render-ui", "drawer", null]
+        ]
+      },
+      {
+        from: "Deleting",
+        to: "Browsing",
+        event: "CANCEL",
+        effects: [
+          ["render-ui", "modal", null]
+        ]
+      }
+    ]
+  },
+  configSchema: {
+    required: [
+      { name: "entity", type: "entity", description: "Entity type to list" },
+      { name: "columns", type: "array", description: "Fields to display as columns" }
+    ],
+    optional: [
+      { name: "title", type: "string", description: "Page title", default: "" },
+      { name: "display", type: "string", description: "Display mode", default: "table", enum: ["table", "cards", "list"] },
+      { name: "actions", type: "action[]", description: "Available actions", default: ["view", "edit", "delete"] },
+      { name: "createInModal", type: "boolean", description: "Show create form in modal", default: true },
+      { name: "editInDrawer", type: "boolean", description: "Show edit form in drawer", default: true }
+    ]
+  }
+};
+var DETAIL_BEHAVIOR = {
+  name: "std/Detail",
+  category: "ui-interaction",
+  description: "Single entity view with edit/delete capabilities",
+  suggestedFor: [
+    "Entity detail pages",
+    "Profile views",
+    "Settings pages",
+    "Single record screens"
+  ],
+  dataEntities: [
+    {
+      name: "DetailState",
+      runtime: true,
+      fields: [
+        { name: "entityId", type: "string", default: null },
+        { name: "isLoading", type: "boolean", default: false },
+        { name: "hasChanges", type: "boolean", default: false }
+      ]
+    }
+  ],
+  stateMachine: {
+    initial: "Viewing",
+    states: [
+      { name: "Viewing", isInitial: true },
+      { name: "Editing" },
+      { name: "Deleting" }
+    ],
+    events: [
+      { key: "INIT" },
+      { key: "EDIT" },
+      { key: "SAVE" },
+      { key: "CANCEL" },
+      { key: "DELETE" },
+      { key: "CONFIRM_DELETE" }
+    ],
+    transitions: [
+      // INIT: Self-loop on Viewing
+      {
+        from: "Viewing",
+        to: "Viewing",
+        event: "INIT",
+        effects: [
+          ["render-ui", "main", {
+            type: "page-header",
+            title: "@entity.name",
+            actions: [
+              { label: "Edit", event: "EDIT" },
+              { label: "Delete", event: "DELETE", variant: "danger" }
+            ]
+          }],
+          ["render-ui", "main", {
+            type: "entity-detail",
+            entity: "@config.entity",
+            fieldNames: "@config.fields"
+          }]
+        ]
+      },
+      {
+        from: "Viewing",
+        to: "Editing",
+        event: "EDIT",
+        effects: [
+          ["render-ui", "main", {
+            type: "form-section",
+            entity: "@config.entity",
+            mode: "edit",
+            fields: "@config.fields",
+            submitEvent: "SAVE",
+            cancelEvent: "CANCEL"
+          }]
+        ]
+      },
+      {
+        from: "Editing",
+        to: "Viewing",
+        event: "SAVE",
+        effects: [
+          ["persist", "update", "@config.entity", "@payload.data"],
+          ["notify", { type: "success", message: "Updated successfully" }],
+          ["emit", "INIT"]
+        ]
+      },
+      {
+        from: "Editing",
+        to: "Viewing",
+        event: "CANCEL",
+        effects: [
+          ["emit", "INIT"]
+        ]
+      },
+      {
+        from: "Viewing",
+        to: "Deleting",
+        event: "DELETE",
+        effects: [
+          ["render-ui", "modal", {
+            type: "confirmation",
+            title: "Delete Confirmation",
+            message: "Are you sure you want to delete this item?"
+          }]
+        ]
+      },
+      {
+        from: "Deleting",
+        to: "Viewing",
+        event: "CONFIRM_DELETE",
+        effects: [
+          ["persist", "delete", "@config.entity", "@entity.id"],
+          ["navigate", "@config.returnUrl"]
+        ]
+      },
+      {
+        from: "Deleting",
+        to: "Viewing",
+        event: "CANCEL",
+        effects: [
+          ["render-ui", "modal", null]
+        ]
+      }
+    ]
+  },
+  configSchema: {
+    required: [
+      { name: "entity", type: "entity", description: "Entity type" },
+      { name: "fields", type: "array", description: "Fields to display" }
+    ],
+    optional: [
+      { name: "layout", type: "string", description: "Layout mode", default: "two-column", enum: ["single-column", "two-column", "grid"] },
+      { name: "allowEdit", type: "boolean", description: "Allow editing", default: true },
+      { name: "allowDelete", type: "boolean", description: "Allow deletion", default: true }
+    ]
+  }
+};
+var FORM_BEHAVIOR = {
+  name: "std/Form",
+  category: "ui-interaction",
+  description: "Form state management with validation and submission",
+  suggestedFor: [
+    "Create/edit forms",
+    "Settings forms",
+    "Multi-field input",
+    "Validated data entry"
+  ],
+  dataEntities: [
+    {
+      name: "FormState",
+      runtime: true,
+      fields: [
+        { name: "values", type: "object", default: {} },
+        { name: "errors", type: "object", default: {} },
+        { name: "touched", type: "object", default: {} },
+        { name: "isDirty", type: "boolean", default: false },
+        { name: "isSubmitting", type: "boolean", default: false }
+      ]
+    }
+  ],
+  stateMachine: {
+    initial: "Idle",
+    states: [
+      { name: "Idle", isInitial: true },
+      { name: "Editing" },
+      { name: "Validating" },
+      { name: "Submitting" },
+      { name: "Success" },
+      { name: "Error" }
+    ],
+    events: [
+      { key: "INIT" },
+      { key: "FIELD_CHANGE" },
+      { key: "FIELD_BLUR" },
+      { key: "SUBMIT" },
+      { key: "VALIDATION_PASSED" },
+      { key: "VALIDATION_FAILED" },
+      { key: "SUBMIT_SUCCESS" },
+      { key: "SUBMIT_ERROR" },
+      { key: "RESET" }
+    ],
+    transitions: [
+      // INIT: Self-loop on Idle → Editing
+      {
+        from: "Idle",
+        to: "Editing",
+        event: "INIT",
+        effects: [
+          ["render-ui", "main", {
+            type: "form-section",
+            entity: "@config.entity",
+            fields: "@config.fields",
+            values: "@entity.values",
+            errors: "@entity.errors",
+            submitEvent: "SUBMIT",
+            cancelEvent: "@config.cancelEvent"
+          }]
+        ]
+      },
+      {
+        from: "Editing",
+        to: "Editing",
+        event: "FIELD_CHANGE",
+        effects: [
+          ["set", "@entity.values", ["object/set", "@entity.values", "@payload.field", "@payload.value"]],
+          ["set", "@entity.isDirty", true]
+        ]
+      },
+      {
+        from: "Editing",
+        to: "Editing",
+        event: "FIELD_BLUR",
+        effects: [
+          ["set", "@entity.touched", ["object/set", "@entity.touched", "@payload.field", true]]
+        ]
+      },
+      {
+        from: "Editing",
+        to: "Validating",
+        event: "SUBMIT",
+        effects: [
+          [
+            "let",
+            [["result", ["validate/check", "@entity.values", "@config.validation"]]],
+            [
+              "if",
+              "@result.valid",
+              ["emit", "VALIDATION_PASSED"],
+              [
+                "do",
+                ["set", "@entity.errors", "@result.errors"],
+                ["emit", "VALIDATION_FAILED"]
+              ]
+            ]
+          ]
+        ]
+      },
+      {
+        from: "Validating",
+        to: "Submitting",
+        event: "VALIDATION_PASSED",
+        effects: [
+          ["set", "@entity.isSubmitting", true],
+          [
+            "if",
+            ["=", "@config.mode", "create"],
+            ["persist", "create", "@config.entity", "@entity.values"],
+            ["persist", "update", "@config.entity", "@entity.values"]
+          ]
+        ]
+      },
+      {
+        from: "Validating",
+        to: "Editing",
+        event: "VALIDATION_FAILED",
+        effects: [
+          ["notify", { type: "error", message: "Please fix the validation errors" }]
+        ]
+      },
+      {
+        from: "Submitting",
+        to: "Success",
+        event: "SUBMIT_SUCCESS",
+        effects: [
+          ["set", "@entity.isSubmitting", false],
+          ["notify", { type: "success", message: "Saved successfully" }],
+          ["emit", "@config.submitEvent", { data: "@entity.values" }]
+        ]
+      },
+      {
+        from: "Submitting",
+        to: "Error",
+        event: "SUBMIT_ERROR",
+        effects: [
+          ["set", "@entity.isSubmitting", false],
+          ["set", "@entity.errors", { _form: "@payload.error" }],
+          ["notify", { type: "error", message: "@payload.error" }]
+        ]
+      },
+      {
+        from: "Editing",
+        to: "Idle",
+        event: "RESET",
+        effects: [
+          ["set", "@entity.values", {}],
+          ["set", "@entity.errors", {}],
+          ["set", "@entity.touched", {}],
+          ["set", "@entity.isDirty", false]
+        ]
+      },
+      {
+        from: "Error",
+        to: "Idle",
+        event: "RESET",
+        effects: [
+          ["set", "@entity.values", {}],
+          ["set", "@entity.errors", {}],
+          ["set", "@entity.touched", {}],
+          ["set", "@entity.isDirty", false]
+        ]
+      }
+    ]
+  },
+  configSchema: {
+    required: [
+      { name: "entity", type: "entity", description: "Entity type" },
+      { name: "fields", type: "array", description: "Form fields" }
+    ],
+    optional: [
+      { name: "mode", type: "string", description: "Form mode", default: "create", enum: ["create", "edit"] },
+      { name: "validation", type: "object", description: "Validation rules", default: {} },
+      { name: "submitEvent", type: "event", description: "Event to emit on successful submit", default: "SAVE" },
+      { name: "cancelEvent", type: "event", description: "Event to emit on cancel", default: "CANCEL" }
+    ]
+  }
+};
+var MODAL_BEHAVIOR = {
+  name: "std/Modal",
+  category: "ui-interaction",
+  description: "Modal dialog with open/close state management",
+  suggestedFor: [
+    "Confirmation dialogs",
+    "Create forms",
+    "Detail views",
+    "Any overlay content"
+  ],
+  dataEntities: [
+    {
+      name: "ModalState",
+      runtime: true,
+      fields: [
+        { name: "content", type: "object", default: null }
+      ]
+    }
+  ],
+  stateMachine: {
+    initial: "Closed",
+    states: [
+      { name: "Closed", isInitial: true },
+      { name: "Open" }
+    ],
+    events: [
+      { key: "OPEN" },
+      { key: "CLOSE" },
+      { key: "CONFIRM" }
+    ],
+    transitions: [
+      {
+        from: "Closed",
+        to: "Open",
+        event: "OPEN",
+        effects: [
+          ["set", "@entity.content", "@payload.content"],
+          ["render-ui", "modal", {
+            type: "@payload.type",
+            onClose: "CLOSE"
+          }]
+        ]
+      },
+      {
+        from: "Open",
+        to: "Closed",
+        event: "CLOSE",
+        effects: [
+          ["render-ui", "modal", null]
+        ]
+      },
+      {
+        from: "Open",
+        to: "Closed",
+        event: "CONFIRM",
+        effects: [
+          ["render-ui", "modal", null]
+        ]
+      }
+    ]
+  },
+  configSchema: {
+    required: [],
+    optional: [
+      { name: "size", type: "string", description: "Modal size", default: "md", enum: ["sm", "md", "lg", "xl", "full"] },
+      { name: "closeOnOverlay", type: "boolean", description: "Close on overlay click", default: true },
+      { name: "closeOnEscape", type: "boolean", description: "Close on escape key", default: true }
+    ]
+  }
+};
+var DRAWER_BEHAVIOR = {
+  name: "std/Drawer",
+  category: "ui-interaction",
+  description: "Side drawer panel for detail views and forms",
+  suggestedFor: [
+    "Detail panels",
+    "Edit forms",
+    "Property panels",
+    "Side navigation"
+  ],
+  dataEntities: [
+    {
+      name: "DrawerState",
+      runtime: true,
+      fields: [
+        { name: "content", type: "object", default: null }
+      ]
+    }
+  ],
+  stateMachine: {
+    initial: "Closed",
+    states: [
+      { name: "Closed", isInitial: true },
+      { name: "Open" }
+    ],
+    events: [
+      { key: "OPEN" },
+      { key: "CLOSE" }
+    ],
+    transitions: [
+      {
+        from: "Closed",
+        to: "Open",
+        event: "OPEN",
+        effects: [
+          ["set", "@entity.content", "@payload.content"],
+          ["render-ui", "drawer", {
+            type: "@payload.type",
+            onClose: "CLOSE"
+          }]
+        ]
+      },
+      {
+        from: "Open",
+        to: "Closed",
+        event: "CLOSE",
+        effects: [
+          ["render-ui", "drawer", null]
+        ]
+      }
+    ]
+  },
+  configSchema: {
+    required: [],
+    optional: [
+      { name: "position", type: "string", description: "Drawer position", default: "right", enum: ["left", "right"] },
+      { name: "size", type: "string", description: "Drawer size", default: "md", enum: ["sm", "md", "lg"] },
+      { name: "overlay", type: "boolean", description: "Show overlay", default: true }
+    ]
+  }
+};
+var TABS_BEHAVIOR = {
+  name: "std/Tabs",
+  category: "ui-interaction",
+  description: "Tabbed navigation within a page",
+  suggestedFor: [
+    "Multi-view pages",
+    "Settings with sections",
+    "Dashboard tabs",
+    "Profile sections"
+  ],
+  dataEntities: [
+    {
+      name: "TabsState",
+      runtime: true,
+      singleton: true,
+      fields: [
+        { name: "activeTab", type: "string", default: null }
+      ]
+    }
+  ],
+  stateMachine: {
+    initial: "Active",
+    states: [
+      { name: "Active", isInitial: true }
+    ],
+    events: [
+      { key: "INIT" },
+      { key: "SELECT_TAB" }
+    ],
+    transitions: [
+      // INIT: Self-loop on Active
+      {
+        from: "Active",
+        to: "Active",
+        event: "INIT",
+        effects: [
+          ["set", "@entity.activeTab", "@config.defaultTab"],
+          ["render-ui", "main", {
+            type: "filter-group",
+            filterType: "tabs",
+            tabs: "@config.tabs",
+            active: "@entity.activeTab",
+            onSelect: "SELECT_TAB"
+          }]
+        ]
+      },
+      {
+        from: "Active",
+        to: "Active",
+        event: "SELECT_TAB",
+        effects: [
+          ["set", "@entity.activeTab", "@payload.tabId"]
+        ]
+      }
+    ]
+  },
+  configSchema: {
+    required: [
+      { name: "tabs", type: "array", description: "Tab definitions with id, label, content" }
+    ],
+    optional: [
+      { name: "defaultTab", type: "string", description: "Default active tab ID" }
+    ]
+  }
+};
+var WIZARD_BEHAVIOR = {
+  name: "std/Wizard",
+  category: "ui-interaction",
+  description: "Multi-step wizard flow - each step is a state",
+  suggestedFor: [
+    "Onboarding flows",
+    "Multi-step forms",
+    "Setup wizards",
+    "Checkout flows"
+  ],
+  dataEntities: [
+    {
+      name: "WizardState",
+      runtime: true,
+      singleton: true,
+      fields: [
+        { name: "stepData", type: "object", default: {} }
+      ]
+    }
+  ],
+  // IMPORTANT: Each wizard step is a STATE, not a number index
+  // This is the correct pattern for wizards
+  stateMachine: {
+    initial: "Step1",
+    states: [
+      { name: "Step1", isInitial: true },
+      { name: "Step2" },
+      { name: "Step3" },
+      { name: "Complete" }
+    ],
+    events: [
+      { key: "INIT" },
+      { key: "NEXT" },
+      { key: "PREV" },
+      { key: "COMPLETE" }
+    ],
+    transitions: [
+      // INIT on Step1: Self-loop that renders step 1
+      {
+        from: "Step1",
+        to: "Step1",
+        event: "INIT",
+        effects: [
+          ["render-ui", "main", {
+            type: "wizard-progress",
+            steps: ["Step 1", "Step 2", "Step 3"],
+            current: 0
+          }],
+          ["render-ui", "main", {
+            type: "form-section",
+            entity: "@config.entity",
+            fields: "@config.step1Fields",
+            submitEvent: "NEXT"
+          }]
+        ]
+      },
+      // Step1 → Step2
+      {
+        from: "Step1",
+        to: "Step2",
+        event: "NEXT",
+        effects: [
+          ["set", "@entity.stepData.step1", "@payload"],
+          ["render-ui", "main", {
+            type: "wizard-progress",
+            steps: ["Step 1", "Step 2", "Step 3"],
+            current: 1
+          }],
+          ["render-ui", "main", {
+            type: "form-section",
+            entity: "@config.entity",
+            fields: "@config.step2Fields",
+            submitEvent: "NEXT",
+            cancelEvent: "PREV"
+          }]
+        ]
+      },
+      // Step2 → Step1 (back)
+      {
+        from: "Step2",
+        to: "Step1",
+        event: "PREV",
+        effects: [
+          ["emit", "INIT"]
+        ]
+      },
+      // Step2 → Step3
+      {
+        from: "Step2",
+        to: "Step3",
+        event: "NEXT",
+        effects: [
+          ["set", "@entity.stepData.step2", "@payload"],
+          ["render-ui", "main", {
+            type: "wizard-progress",
+            steps: ["Step 1", "Step 2", "Step 3"],
+            current: 2
+          }],
+          ["render-ui", "main", {
+            type: "entity-detail",
+            entity: "@config.entity",
+            fieldNames: ["step1", "step2"],
+            title: "Review"
+          }],
+          ["render-ui", "main", {
+            type: "form-section",
+            submitLabel: "Complete",
+            cancelLabel: "Back",
+            submitEvent: "COMPLETE",
+            cancelEvent: "PREV"
+          }]
+        ]
+      },
+      // Step3 → Step2 (back)
+      {
+        from: "Step3",
+        to: "Step2",
+        event: "PREV",
+        effects: [
+          ["render-ui", "main", {
+            type: "wizard-progress",
+            steps: ["Step 1", "Step 2", "Step 3"],
+            current: 1
+          }],
+          ["render-ui", "main", {
+            type: "form-section",
+            entity: "@config.entity",
+            fields: "@config.step2Fields",
+            submitEvent: "NEXT",
+            cancelEvent: "PREV"
+          }]
+        ]
+      },
+      // Step3 → Complete
+      {
+        from: "Step3",
+        to: "Complete",
+        event: "COMPLETE",
+        effects: [
+          ["persist", "create", "@config.entity", "@entity.stepData"],
+          ["notify", { type: "success", message: "Wizard completed!" }],
+          ["navigate", "@config.completionUrl"]
+        ]
+      }
+    ]
+  },
+  configSchema: {
+    required: [
+      { name: "entity", type: "entity", description: "Entity to create" },
+      { name: "step1Fields", type: "array", description: "Fields for step 1" },
+      { name: "step2Fields", type: "array", description: "Fields for step 2" }
+    ],
+    optional: [
+      { name: "completionUrl", type: "string", description: "URL to navigate on completion", default: "/" }
+    ]
+  }
+};
+var MASTER_DETAIL_BEHAVIOR = {
+  name: "std/MasterDetail",
+  category: "ui-interaction",
+  description: "Master-detail layout with synchronized list and detail views",
+  suggestedFor: [
+    "Email clients",
+    "File managers",
+    "Two-panel layouts",
+    "List-detail views"
+  ],
+  dataEntities: [
+    {
+      name: "MasterDetailState",
+      runtime: true,
+      singleton: true,
+      fields: [
+        { name: "selectedId", type: "string", default: null }
+      ]
+    }
+  ],
+  stateMachine: {
+    initial: "NoSelection",
+    states: [
+      { name: "NoSelection", isInitial: true },
+      { name: "Selected" }
+    ],
+    events: [
+      { key: "INIT" },
+      { key: "SELECT" },
+      { key: "DESELECT" }
+    ],
+    transitions: [
+      // INIT: Self-loop on NoSelection
+      {
+        from: "NoSelection",
+        to: "NoSelection",
+        event: "INIT",
+        effects: [
+          ["render-ui", "main", {
+            type: "master-detail",
+            entity: "@config.entity",
+            masterColumns: "@config.masterColumns",
+            onSelect: "SELECT",
+            selected: "@entity.selectedId"
+          }],
+          ["render-ui", "main", {
+            type: "empty-state",
+            message: "Select an item to view details"
+          }]
+        ]
+      },
+      {
+        from: "NoSelection",
+        to: "Selected",
+        event: "SELECT",
+        effects: [
+          ["set", "@entity.selectedId", "@payload.id"],
+          ["render-ui", "main", {
+            type: "entity-detail",
+            entity: "@config.entity",
+            id: "@payload.id",
+            fieldNames: "@config.detailFields"
+          }]
+        ]
+      },
+      {
+        from: "Selected",
+        to: "Selected",
+        event: "SELECT",
+        effects: [
+          ["set", "@entity.selectedId", "@payload.id"],
+          ["render-ui", "main", {
+            type: "entity-detail",
+            entity: "@config.entity",
+            id: "@payload.id",
+            fieldNames: "@config.detailFields"
+          }]
+        ]
+      },
+      {
+        from: "Selected",
+        to: "NoSelection",
+        event: "DESELECT",
+        effects: [
+          ["set", "@entity.selectedId", null],
+          ["render-ui", "main", {
+            type: "empty-state",
+            message: "Select an item to view details"
+          }]
+        ]
+      }
+    ]
+  },
+  configSchema: {
+    required: [
+      { name: "entity", type: "entity", description: "Entity type" },
+      { name: "masterColumns", type: "array", description: "Columns for master list" },
+      { name: "detailFields", type: "array", description: "Fields for detail panel" }
+    ],
+    optional: [
+      { name: "masterWidth", type: "string", description: "Master panel width", default: "350px" }
+    ]
+  }
+};
+var FILTER_BEHAVIOR = {
+  name: "std/Filter",
+  category: "ui-interaction",
+  description: "Filter and search management for lists",
+  suggestedFor: [
+    "Filtered lists",
+    "Search interfaces",
+    "Faceted navigation",
+    "Advanced filtering"
+  ],
+  dataEntities: [
+    {
+      name: "FilterState",
+      runtime: true,
+      singleton: true,
+      fields: [
+        { name: "filters", type: "object", default: {} },
+        { name: "searchTerm", type: "string", default: "" }
+      ]
+    }
+  ],
+  stateMachine: {
+    initial: "Idle",
+    states: [
+      { name: "Idle", isInitial: true },
+      { name: "Filtering" }
+    ],
+    events: [
+      { key: "INIT" },
+      { key: "SET_FILTER" },
+      { key: "CLEAR_FILTERS" },
+      { key: "SEARCH" }
+    ],
+    transitions: [
+      // INIT: Self-loop
+      {
+        from: "Idle",
+        to: "Idle",
+        event: "INIT",
+        effects: [
+          ["render-ui", "main", {
+            type: "filter-group",
+            filters: "@config.filters",
+            values: "@entity.filters",
+            onFilterChange: "SET_FILTER",
+            onClear: "CLEAR_FILTERS"
+          }]
+        ]
+      },
+      {
+        from: "Idle",
+        to: "Filtering",
+        event: "SET_FILTER",
+        effects: [
+          ["set", "@entity.filters", ["object/set", "@entity.filters", "@payload.field", "@payload.value"]],
+          ["emit", "FILTER_CHANGED", "@entity.filters"]
+        ]
+      },
+      {
+        from: "Filtering",
+        to: "Idle",
+        event: "SET_FILTER",
+        effects: [
+          ["set", "@entity.filters", ["object/set", "@entity.filters", "@payload.field", "@payload.value"]],
+          ["emit", "FILTER_CHANGED", "@entity.filters"]
+        ]
+      },
+      {
+        from: "Filtering",
+        to: "Idle",
+        event: "CLEAR_FILTERS",
+        effects: [
+          ["set", "@entity.filters", {}],
+          ["set", "@entity.searchTerm", ""],
+          ["emit", "FILTER_CHANGED", {}]
+        ]
+      },
+      {
+        from: "Idle",
+        to: "Filtering",
+        event: "SEARCH",
+        effects: [
+          ["set", "@entity.searchTerm", "@payload.term"],
+          ["emit", "SEARCH_CHANGED", "@payload.term"]
+        ]
+      }
+    ]
+  },
+  configSchema: {
+    required: [
+      { name: "filters", type: "array", description: "Filter definitions" }
+    ],
+    optional: [
+      { name: "searchable", type: "boolean", description: "Enable search", default: true }
+    ]
+  }
+};
+var UI_INTERACTION_BEHAVIORS = [
+  LIST_BEHAVIOR,
+  DETAIL_BEHAVIOR,
+  FORM_BEHAVIOR,
+  MODAL_BEHAVIOR,
+  DRAWER_BEHAVIOR,
+  TABS_BEHAVIOR,
+  WIZARD_BEHAVIOR,
+  MASTER_DETAIL_BEHAVIOR,
+  FILTER_BEHAVIOR
+];
+
+// behaviors/data-management.ts
+var PAGINATION_BEHAVIOR = {
+  name: "std/Pagination",
+  category: "data-management",
+  description: "Page-based navigation for large data sets",
+  suggestedFor: [
+    "Large lists",
+    "Table pagination",
+    "Infinite scroll alternative",
+    "Data-heavy views"
+  ],
+  dataEntities: [
+    {
+      name: "PaginationState",
+      runtime: true,
+      singleton: true,
+      fields: [
+        { name: "page", type: "number", default: 1 },
+        { name: "pageSize", type: "number", default: 20 },
+        { name: "totalItems", type: "number", default: 0 }
+      ]
+    }
+  ],
+  stateMachine: {
+    initial: "Active",
+    states: [
+      { name: "Active", isInitial: true }
+    ],
+    events: [
+      { key: "INIT" },
+      { key: "NEXT_PAGE" },
+      { key: "PREV_PAGE" },
+      { key: "GO_TO_PAGE" },
+      { key: "SET_PAGE_SIZE" }
+    ],
+    transitions: [
+      {
+        from: "*",
+        event: "INIT",
+        effects: [
+          ["set", "@entity.page", 1],
+          ["set", "@entity.pageSize", "@config.defaultPageSize"]
+        ]
+      },
+      {
+        event: "NEXT_PAGE",
+        guard: ["<", "@entity.page", ["math/ceil", ["/", "@entity.totalItems", "@entity.pageSize"]]],
+        effects: [
+          ["set", "@entity.page", ["+", "@entity.page", 1]]
+        ]
+      },
+      {
+        event: "PREV_PAGE",
+        guard: [">", "@entity.page", 1],
+        effects: [
+          ["set", "@entity.page", ["-", "@entity.page", 1]]
+        ]
+      },
+      {
+        event: "GO_TO_PAGE",
+        guard: [
+          "and",
+          [">=", "@payload.page", 1],
+          ["<=", "@payload.page", ["math/ceil", ["/", "@entity.totalItems", "@entity.pageSize"]]]
+        ],
+        effects: [
+          ["set", "@entity.page", "@payload.page"]
+        ]
+      },
+      {
+        event: "SET_PAGE_SIZE",
+        effects: [
+          ["set", "@entity.pageSize", "@payload.size"],
+          ["set", "@entity.page", 1]
+        ]
+      }
+    ]
+  },
+  configSchema: {
+    required: [],
+    optional: [
+      { name: "defaultPageSize", type: "number", description: "Default items per page", default: 20 },
+      { name: "pageSizeOptions", type: "array", description: "Available page sizes", default: [10, 20, 50, 100] }
+    ]
+  }
+};
+var SELECTION_BEHAVIOR = {
+  name: "std/Selection",
+  category: "data-management",
+  description: "Single or multi-selection management",
+  suggestedFor: [
+    "Multi-select lists",
+    "Bulk operations",
+    "Item picking",
+    "Checkboxes in tables"
+  ],
+  dataEntities: [
+    {
+      name: "SelectionState",
+      runtime: true,
+      singleton: true,
+      fields: [
+        { name: "selected", type: "array", default: [] },
+        { name: "lastSelected", type: "string", default: null }
+      ]
+    }
+  ],
+  stateMachine: {
+    initial: "Active",
+    states: [
+      { name: "Active", isInitial: true }
+    ],
+    events: [
+      { key: "INIT" },
+      { key: "SELECT" },
+      { key: "DESELECT" },
+      { key: "TOGGLE" },
+      { key: "SELECT_ALL" },
+      { key: "CLEAR" }
+    ],
+    transitions: [
+      {
+        from: "*",
+        event: "INIT",
+        effects: [
+          ["set", "@entity.selected", []],
+          ["set", "@entity.lastSelected", null]
+        ]
+      },
+      {
+        event: "SELECT",
+        effects: [
+          [
+            "if",
+            ["=", "@config.mode", "single"],
+            [
+              "do",
+              ["set", "@entity.selected", ["@payload.id"]],
+              ["set", "@entity.lastSelected", "@payload.id"]
+            ],
+            [
+              "if",
+              [
+                "or",
+                ["not", "@config.maxSelection"],
+                ["<", ["array/len", "@entity.selected"], "@config.maxSelection"]
+              ],
+              [
+                "do",
+                ["set", "@entity.selected", ["array/append", "@entity.selected", "@payload.id"]],
+                ["set", "@entity.lastSelected", "@payload.id"]
+              ],
+              ["notify", { type: "warning", message: "Maximum selection reached" }]
+            ]
+          ]
+        ]
+      },
+      {
+        event: "DESELECT",
+        effects: [
+          ["set", "@entity.selected", ["array/filter", "@entity.selected", ["fn", "id", ["!=", "@id", "@payload.id"]]]]
+        ]
+      },
+      {
+        event: "TOGGLE",
+        effects: [
+          [
+            "if",
+            ["array/includes", "@entity.selected", "@payload.id"],
+            ["set", "@entity.selected", ["array/filter", "@entity.selected", ["fn", "id", ["!=", "@id", "@payload.id"]]]],
+            [
+              "if",
+              ["or", ["=", "@config.mode", "single"], [
+                "or",
+                ["not", "@config.maxSelection"],
+                ["<", ["array/len", "@entity.selected"], "@config.maxSelection"]
+              ]],
+              [
+                "set",
+                "@entity.selected",
+                [
+                  "if",
+                  ["=", "@config.mode", "single"],
+                  ["@payload.id"],
+                  ["array/append", "@entity.selected", "@payload.id"]
+                ]
+              ],
+              ["notify", { type: "warning", message: "Maximum selection reached" }]
+            ]
+          ]
+        ]
+      },
+      {
+        event: "SELECT_ALL",
+        guard: ["=", "@config.mode", "multi"],
+        effects: [
+          ["set", "@entity.selected", "@payload.ids"]
+        ]
+      },
+      {
+        event: "CLEAR",
+        effects: [
+          ["set", "@entity.selected", []],
+          ["set", "@entity.lastSelected", null]
+        ]
+      }
+    ]
+  },
+  configSchema: {
+    required: [],
+    optional: [
+      { name: "mode", type: "string", description: "Selection mode", default: "single", enum: ["single", "multi"] },
+      { name: "maxSelection", type: "number", description: "Maximum selections (multi mode)", default: null }
+    ]
+  }
+};
+var SORT_BEHAVIOR = {
+  name: "std/Sort",
+  category: "data-management",
+  description: "Sorting by field with direction toggle",
+  suggestedFor: [
+    "Sortable tables",
+    "List ordering",
+    "Column headers"
+  ],
+  dataEntities: [
+    {
+      name: "SortState",
+      runtime: true,
+      singleton: true,
+      fields: [
+        { name: "sortField", type: "string", default: null },
+        { name: "sortDirection", type: "string", default: "asc" }
+      ]
+    }
+  ],
+  stateMachine: {
+    initial: "Active",
+    states: [
+      { name: "Active", isInitial: true }
+    ],
+    events: [
+      { key: "INIT" },
+      { key: "SORT" },
+      { key: "TOGGLE_DIRECTION" },
+      { key: "CLEAR_SORT" }
+    ],
+    transitions: [
+      {
+        from: "*",
+        event: "INIT",
+        effects: [
+          ["set", "@entity.sortField", "@config.defaultField"],
+          ["set", "@entity.sortDirection", "@config.defaultDirection"]
+        ]
+      },
+      {
+        event: "SORT",
+        effects: [
+          [
+            "if",
+            ["=", "@entity.sortField", "@payload.field"],
+            ["set", "@entity.sortDirection", ["if", ["=", "@entity.sortDirection", "asc"], "desc", "asc"]],
+            [
+              "do",
+              ["set", "@entity.sortField", "@payload.field"],
+              ["set", "@entity.sortDirection", "asc"]
+            ]
+          ]
+        ]
+      },
+      {
+        event: "TOGGLE_DIRECTION",
+        guard: ["!=", "@entity.sortField", null],
+        effects: [
+          ["set", "@entity.sortDirection", ["if", ["=", "@entity.sortDirection", "asc"], "desc", "asc"]]
+        ]
+      },
+      {
+        event: "CLEAR_SORT",
+        effects: [
+          ["set", "@entity.sortField", null],
+          ["set", "@entity.sortDirection", "asc"]
+        ]
+      }
+    ]
+  },
+  configSchema: {
+    required: [],
+    optional: [
+      { name: "defaultField", type: "string", description: "Default sort field" },
+      { name: "defaultDirection", type: "string", description: "Default direction", default: "asc", enum: ["asc", "desc"] }
+    ]
+  }
+};
+var FILTER_BEHAVIOR2 = {
+  name: "std/Filter",
+  category: "data-management",
+  description: "Query Singleton pattern for explicit filtering - use with entity-table query prop",
+  suggestedFor: [
+    "Filterable lists",
+    "Advanced search",
+    "Filter panels",
+    "Faceted search",
+    "Entity tables with filters"
+  ],
+  dataEntities: [
+    {
+      name: "QueryState",
+      runtime: true,
+      singleton: true,
+      fields: [
+        { name: "status", type: "string", default: null, description: "Filter by status field" },
+        { name: "priority", type: "string", default: null, description: "Filter by priority field" },
+        { name: "search", type: "string", default: "", description: "Search term" },
+        { name: "sortBy", type: "string", default: "createdAt", description: "Sort field" },
+        { name: "sortOrder", type: "string", default: "desc", description: "Sort direction: asc or desc" }
+      ]
+    }
+  ],
+  stateMachine: {
+    initial: "Active",
+    states: [
+      { name: "Active", isInitial: true }
+    ],
+    events: [
+      { key: "INIT" },
+      { key: "FILTER" },
+      { key: "SEARCH" },
+      { key: "SORT" },
+      { key: "CLEAR_FILTERS" }
+    ],
+    transitions: [
+      {
+        from: "*",
+        event: "INIT",
+        effects: [
+          // Render filter UI with query reference
+          ["render-ui", "sidebar", {
+            type: "filter-group",
+            query: "@QueryState",
+            filters: "@config.filters"
+          }],
+          // Render entity table with query reference
+          ["render-ui", "main", {
+            type: "entity-table",
+            entity: "@config.entity",
+            query: "@QueryState",
+            columns: "@config.columns"
+          }]
+        ]
+      },
+      {
+        event: "FILTER",
+        effects: [
+          ["set", "@QueryState.status", "@payload.status"],
+          ["set", "@QueryState.priority", "@payload.priority"]
+        ]
+      },
+      {
+        event: "SEARCH",
+        effects: [
+          ["set", "@QueryState.search", "@payload.searchTerm"]
+        ]
+      },
+      {
+        event: "SORT",
+        effects: [
+          ["set", "@QueryState.sortBy", "@payload.field"],
+          ["set", "@QueryState.sortOrder", "@payload.order"]
+        ]
+      },
+      {
+        event: "CLEAR_FILTERS",
+        effects: [
+          ["set", "@QueryState.status", null],
+          ["set", "@QueryState.priority", null],
+          ["set", "@QueryState.search", ""]
+        ]
+      }
+    ]
+  },
+  configSchema: {
+    required: [
+      { name: "entity", type: "string", description: "Entity to filter" }
+    ],
+    optional: [
+      { name: "filters", type: "array", description: "Filter field definitions", default: [] },
+      { name: "columns", type: "array", description: "Table columns to display", default: [] }
+    ]
+  }
+};
+var SEARCH_BEHAVIOR = {
+  name: "std/Search",
+  category: "data-management",
+  description: "Search with debounce - updates QueryState.search field",
+  suggestedFor: [
+    "Search inputs",
+    "Quick filters",
+    "Global search",
+    "Type-ahead"
+  ],
+  dataEntities: [
+    {
+      name: "SearchState",
+      runtime: true,
+      singleton: true,
+      fields: [
+        { name: "search", type: "string", default: "" },
+        { name: "isSearching", type: "boolean", default: false }
+      ]
+    }
+  ],
+  stateMachine: {
+    initial: "Idle",
+    states: [
+      { name: "Idle", isInitial: true },
+      { name: "Searching" }
+    ],
+    events: [
+      { key: "INIT" },
+      { key: "SEARCH" },
+      { key: "CLEAR_SEARCH" },
+      { key: "SEARCH_COMPLETE" }
+    ],
+    transitions: [
+      {
+        from: "*",
+        event: "INIT",
+        effects: [
+          ["set", "@entity.search", ""],
+          ["set", "@entity.isSearching", false],
+          ["render-ui", "main", {
+            type: "search-bar",
+            query: "@SearchState",
+            placeholder: "@config.placeholder"
+          }]
+        ]
+      },
+      {
+        from: "Idle",
+        to: "Searching",
+        event: "SEARCH",
+        guard: [">=", ["str/len", "@payload.term"], "@config.minLength"],
+        effects: [
+          ["set", "@entity.search", "@payload.term"],
+          ["set", "@entity.isSearching", true],
+          ["async/debounce", "@config.debounceMs", ["emit", "SEARCH_COMPLETE"]]
+        ]
+      },
+      {
+        from: "Idle",
+        event: "SEARCH",
+        guard: ["<", ["str/len", "@payload.term"], "@config.minLength"],
+        effects: [
+          ["set", "@entity.search", "@payload.term"]
+        ]
+      },
+      {
+        from: "Searching",
+        to: "Idle",
+        event: "SEARCH_COMPLETE",
+        effects: [
+          ["set", "@entity.isSearching", false]
+        ]
+      },
+      {
+        event: "CLEAR_SEARCH",
+        effects: [
+          ["set", "@entity.search", ""],
+          ["set", "@entity.isSearching", false]
+        ]
+      }
+    ]
+  },
+  configSchema: {
+    required: [],
+    optional: [
+      { name: "debounceMs", type: "number", description: "Debounce delay in ms", default: 300 },
+      { name: "minLength", type: "number", description: "Minimum search length", default: 1 },
+      { name: "placeholder", type: "string", description: "Input placeholder", default: "Search..." }
+    ]
+  }
+};
+var DATA_MANAGEMENT_BEHAVIORS = [
+  PAGINATION_BEHAVIOR,
+  SELECTION_BEHAVIOR,
+  SORT_BEHAVIOR,
+  FILTER_BEHAVIOR2,
+  SEARCH_BEHAVIOR
+];
+
+// behaviors/async.ts
+var LOADING_BEHAVIOR = {
+  name: "std/Loading",
+  category: "async",
+  description: "Loading state management with success/error handling",
+  suggestedFor: [
+    "Async data loading",
+    "API calls",
+    "Resource fetching",
+    "Initial page load"
+  ],
+  dataEntities: [
+    {
+      name: "LoadingState",
+      runtime: true,
+      singleton: true,
+      fields: [
+        { name: "isLoading", type: "boolean", default: false },
+        { name: "error", type: "object", default: null },
+        { name: "data", type: "object", default: null },
+        { name: "startTime", type: "number", default: null }
+      ]
+    }
+  ],
+  stateMachine: {
+    initial: "Idle",
+    states: [
+      { name: "Idle", isInitial: true },
+      { name: "Loading" },
+      { name: "Success" },
+      { name: "Error" }
+    ],
+    events: [
+      { key: "START" },
+      { key: "SUCCESS" },
+      { key: "ERROR" },
+      { key: "RETRY" },
+      { key: "RESET" }
+    ],
+    transitions: [
+      {
+        from: "Idle",
+        to: "Loading",
+        event: "START",
+        effects: [
+          ["set", "@entity.isLoading", true],
+          ["set", "@entity.error", null],
+          ["set", "@entity.startTime", ["time/now"]],
+          ["render", "content", "loading-state", {}]
+        ]
+      },
+      {
+        from: "Loading",
+        to: "Success",
+        event: "SUCCESS",
+        effects: [
+          ["set", "@entity.isLoading", false],
+          ["set", "@entity.data", "@payload.data"]
+        ]
+      },
+      {
+        from: "Loading",
+        to: "Error",
+        event: "ERROR",
+        effects: [
+          ["set", "@entity.isLoading", false],
+          ["set", "@entity.error", "@payload.error"],
+          ["render", "content", "error-state", {
+            error: "@entity.error",
+            onRetry: "RETRY"
+          }]
+        ]
+      },
+      {
+        from: "Error",
+        to: "Loading",
+        event: "RETRY",
+        effects: [
+          ["set", "@entity.isLoading", true],
+          ["set", "@entity.error", null],
+          ["set", "@entity.startTime", ["time/now"]],
+          ["render", "content", "loading-state", {}]
+        ]
+      },
+      {
+        from: ["Success", "Error"],
+        to: "Idle",
+        event: "RESET",
+        effects: [
+          ["set", "@entity.isLoading", false],
+          ["set", "@entity.error", null],
+          ["set", "@entity.data", null]
+        ]
+      }
+    ]
+  },
+  configSchema: {
+    required: [],
+    optional: [
+      { name: "showLoadingAfterMs", type: "number", description: "Delay before showing loading", default: 200 },
+      { name: "minLoadingMs", type: "number", description: "Minimum loading display time", default: 500 }
+    ]
+  }
+};
+var FETCH_BEHAVIOR = {
+  name: "std/Fetch",
+  category: "async",
+  description: "Data fetching with caching and refresh capabilities",
+  suggestedFor: [
+    "API data fetching",
+    "Entity loading",
+    "Remote data",
+    "Cached queries"
+  ],
+  dataEntities: [
+    {
+      name: "FetchState",
+      runtime: true,
+      singleton: true,
+      fields: [
+        { name: "data", type: "object", default: null },
+        { name: "error", type: "object", default: null },
+        { name: "isFetching", type: "boolean", default: false },
+        { name: "lastFetchedAt", type: "number", default: null }
+      ]
+    }
+  ],
+  stateMachine: {
+    initial: "Idle",
+    states: [
+      { name: "Idle", isInitial: true },
+      { name: "Fetching" },
+      { name: "Stale" },
+      { name: "Fresh" },
+      { name: "Error" }
+    ],
+    events: [
+      { key: "FETCH" },
+      { key: "FETCH_SUCCESS" },
+      { key: "FETCH_ERROR" },
+      { key: "REFRESH" },
+      { key: "INVALIDATE" }
+    ],
+    transitions: [
+      {
+        from: ["Idle", "Stale"],
+        to: "Fetching",
+        event: "FETCH",
+        effects: [
+          ["set", "@entity.isFetching", true],
+          ["set", "@entity.error", null]
+        ]
+      },
+      {
+        from: "Fetching",
+        to: "Fresh",
+        event: "FETCH_SUCCESS",
+        effects: [
+          ["set", "@entity.isFetching", false],
+          ["set", "@entity.data", "@payload.data"],
+          ["set", "@entity.lastFetchedAt", ["time/now"]]
+        ]
+      },
+      {
+        from: "Fetching",
+        to: "Error",
+        event: "FETCH_ERROR",
+        effects: [
+          ["set", "@entity.isFetching", false],
+          ["set", "@entity.error", "@payload.error"]
+        ]
+      },
+      {
+        from: "Fresh",
+        to: "Stale",
+        event: "INVALIDATE",
+        effects: [
+          ["set", "@entity.lastFetchedAt", null]
+        ]
+      },
+      {
+        from: ["Fresh", "Stale", "Error"],
+        to: "Fetching",
+        event: "REFRESH",
+        effects: [
+          ["set", "@entity.isFetching", true],
+          ["set", "@entity.error", null]
+        ]
+      }
+    ]
+  },
+  configSchema: {
+    required: [
+      { name: "entity", type: "entity", description: "Entity type to fetch" }
+    ],
+    optional: [
+      { name: "staleTimeMs", type: "number", description: "Time until data is stale", default: 6e4 },
+      { name: "cacheKey", type: "string", description: "Cache key for deduplication" }
+    ]
+  }
+};
+var SUBMIT_BEHAVIOR = {
+  name: "std/Submit",
+  category: "async",
+  description: "Async submission with retry capabilities",
+  suggestedFor: [
+    "Form submission",
+    "Data saving",
+    "API mutations",
+    "Actions with confirmation"
+  ],
+  dataEntities: [
+    {
+      name: "SubmitState",
+      runtime: true,
+      singleton: true,
+      fields: [
+        { name: "isSubmitting", type: "boolean", default: false },
+        { name: "error", type: "object", default: null },
+        { name: "lastSubmittedData", type: "object", default: null }
+      ]
+    }
+  ],
+  stateMachine: {
+    initial: "Idle",
+    states: [
+      { name: "Idle", isInitial: true },
+      { name: "Submitting" },
+      { name: "Success" },
+      { name: "Error" }
+    ],
+    events: [
+      { key: "SUBMIT" },
+      { key: "SUBMIT_SUCCESS" },
+      { key: "SUBMIT_ERROR" },
+      { key: "RETRY" },
+      { key: "RESET" }
+    ],
+    transitions: [
+      {
+        from: "Idle",
+        to: "Submitting",
+        event: "SUBMIT",
+        effects: [
+          ["set", "@entity.isSubmitting", true],
+          ["set", "@entity.error", null],
+          ["set", "@entity.lastSubmittedData", "@payload.data"]
+        ]
+      },
+      {
+        from: "Submitting",
+        to: "Success",
+        event: "SUBMIT_SUCCESS",
+        effects: [
+          ["set", "@entity.isSubmitting", false],
+          ["notify", { type: "success", message: "@config.successMessage" }],
+          ["when", "@config.resetOnSuccess", ["emit", "RESET"]]
+        ]
+      },
+      {
+        from: "Submitting",
+        to: "Error",
+        event: "SUBMIT_ERROR",
+        effects: [
+          ["set", "@entity.isSubmitting", false],
+          ["set", "@entity.error", "@payload.error"],
+          ["notify", { type: "error", message: "@config.errorMessage" }]
+        ]
+      },
+      {
+        from: "Error",
+        to: "Submitting",
+        event: "RETRY",
+        effects: [
+          ["set", "@entity.isSubmitting", true],
+          ["set", "@entity.error", null]
+        ]
+      },
+      {
+        from: ["Success", "Error"],
+        to: "Idle",
+        event: "RESET",
+        effects: [
+          ["set", "@entity.isSubmitting", false],
+          ["set", "@entity.error", null],
+          ["set", "@entity.lastSubmittedData", null]
+        ]
+      }
+    ]
+  },
+  configSchema: {
+    required: [],
+    optional: [
+      { name: "successMessage", type: "string", description: "Success notification", default: "Saved successfully" },
+      { name: "errorMessage", type: "string", description: "Error notification", default: "Failed to save" },
+      { name: "resetOnSuccess", type: "boolean", description: "Reset to idle on success", default: false }
+    ]
+  }
+};
+var RETRY_BEHAVIOR = {
+  name: "std/Retry",
+  category: "async",
+  description: "Automatic retry with exponential backoff",
+  suggestedFor: [
+    "Network requests",
+    "Unreliable operations",
+    "Transient failures",
+    "Recovery logic"
+  ],
+  dataEntities: [
+    {
+      name: "RetryState",
+      runtime: true,
+      singleton: true,
+      fields: [
+        { name: "attempt", type: "number", default: 0 },
+        { name: "error", type: "object", default: null },
+        { name: "nextRetryAt", type: "number", default: null }
+      ]
+    }
+  ],
+  stateMachine: {
+    initial: "Idle",
+    states: [
+      { name: "Idle", isInitial: true },
+      { name: "Attempting" },
+      { name: "Waiting" },
+      { name: "Success" },
+      { name: "Failed" }
+    ],
+    events: [
+      { key: "START" },
+      { key: "ATTEMPT_SUCCESS" },
+      { key: "ATTEMPT_ERROR" },
+      { key: "RETRY_TICK" },
+      { key: "GIVE_UP" },
+      { key: "RESET" }
+    ],
+    transitions: [
+      {
+        from: "Idle",
+        to: "Attempting",
+        event: "START",
+        effects: [
+          ["set", "@entity.attempt", 1],
+          ["set", "@entity.error", null]
+        ]
+      },
+      {
+        from: "Attempting",
+        to: "Success",
+        event: "ATTEMPT_SUCCESS",
+        effects: []
+      },
+      {
+        from: "Attempting",
+        to: "Waiting",
+        event: "ATTEMPT_ERROR",
+        guard: ["<", "@entity.attempt", "@config.maxAttempts"],
+        effects: [
+          ["set", "@entity.error", "@payload.error"],
+          [
+            "let",
+            [["delay", [
+              "math/min",
+              ["*", "@config.initialDelayMs", ["math/pow", "@config.backoffMultiplier", "@entity.attempt"]],
+              "@config.maxDelayMs"
+            ]]],
+            ["set", "@entity.nextRetryAt", ["+", ["time/now"], "@delay"]],
+            ["async/delay", "@delay", ["emit", "RETRY_TICK"]]
+          ]
+        ]
+      },
+      {
+        from: "Attempting",
+        to: "Failed",
+        event: "ATTEMPT_ERROR",
+        guard: [">=", "@entity.attempt", "@config.maxAttempts"],
+        effects: [
+          ["set", "@entity.error", "@payload.error"],
+          ["notify", { type: "error", message: "All retry attempts failed" }]
+        ]
+      },
+      {
+        from: "Waiting",
+        to: "Attempting",
+        event: "RETRY_TICK",
+        effects: [
+          ["set", "@entity.attempt", ["+", "@entity.attempt", 1]]
+        ]
+      },
+      {
+        from: "Waiting",
+        to: "Failed",
+        event: "GIVE_UP",
+        effects: [
+          ["notify", { type: "warning", message: "Retry cancelled" }]
+        ]
+      },
+      {
+        from: ["Success", "Failed"],
+        to: "Idle",
+        event: "RESET",
+        effects: [
+          ["set", "@entity.attempt", 0],
+          ["set", "@entity.error", null],
+          ["set", "@entity.nextRetryAt", null]
+        ]
+      }
+    ]
+  },
+  configSchema: {
+    required: [],
+    optional: [
+      { name: "maxAttempts", type: "number", description: "Maximum retry attempts", default: 3 },
+      { name: "initialDelayMs", type: "number", description: "Initial retry delay", default: 1e3 },
+      { name: "maxDelayMs", type: "number", description: "Maximum retry delay", default: 3e4 },
+      { name: "backoffMultiplier", type: "number", description: "Backoff multiplier", default: 2 }
+    ]
+  }
+};
+var POLL_BEHAVIOR = {
+  name: "std/Poll",
+  category: "async",
+  description: "Periodic polling with start/stop control",
+  suggestedFor: [
+    "Real-time updates",
+    "Status checking",
+    "Live data",
+    "Notification polling"
+  ],
+  dataEntities: [
+    {
+      name: "PollState",
+      runtime: true,
+      singleton: true,
+      fields: [
+        { name: "isPolling", type: "boolean", default: false },
+        { name: "pollCount", type: "number", default: 0 },
+        { name: "lastPollAt", type: "number", default: null },
+        { name: "error", type: "object", default: null }
+      ]
+    }
+  ],
+  stateMachine: {
+    initial: "Stopped",
+    states: [
+      { name: "Stopped", isInitial: true },
+      { name: "Polling" },
+      { name: "Paused" }
+    ],
+    events: [
+      { key: "START" },
+      { key: "STOP" },
+      { key: "PAUSE" },
+      { key: "RESUME" },
+      { key: "POLL_TICK" },
+      { key: "POLL_SUCCESS" },
+      { key: "POLL_ERROR" }
+    ],
+    transitions: [
+      {
+        from: "Stopped",
+        to: "Polling",
+        event: "START",
+        effects: [
+          ["set", "@entity.isPolling", true],
+          ["set", "@entity.pollCount", 0],
+          ["async/interval", "@config.intervalMs", ["emit", "POLL_TICK"]]
+        ]
+      },
+      {
+        from: "Polling",
+        event: "POLL_TICK",
+        guard: ["or", ["=", "@config.maxPolls", null], ["<", "@entity.pollCount", "@config.maxPolls"]],
+        effects: [
+          ["set", "@entity.lastPollAt", ["time/now"]]
+        ]
+      },
+      {
+        from: "Polling",
+        event: "POLL_SUCCESS",
+        effects: [
+          ["set", "@entity.pollCount", ["+", "@entity.pollCount", 1]],
+          ["set", "@entity.error", null]
+        ]
+      },
+      {
+        from: "Polling",
+        event: "POLL_ERROR",
+        effects: [
+          ["set", "@entity.error", "@payload.error"],
+          ["when", "@config.stopOnError", ["emit", "STOP"]]
+        ]
+      },
+      {
+        from: "Polling",
+        to: "Paused",
+        event: "PAUSE",
+        effects: [
+          ["set", "@entity.isPolling", false]
+        ]
+      },
+      {
+        from: "Paused",
+        to: "Polling",
+        event: "RESUME",
+        effects: [
+          ["set", "@entity.isPolling", true],
+          ["async/interval", "@config.intervalMs", ["emit", "POLL_TICK"]]
+        ]
+      },
+      {
+        from: ["Polling", "Paused"],
+        to: "Stopped",
+        event: "STOP",
+        effects: [
+          ["set", "@entity.isPolling", false]
+        ]
+      }
+    ]
+  },
+  configSchema: {
+    required: [],
+    optional: [
+      { name: "intervalMs", type: "number", description: "Poll interval in ms", default: 5e3 },
+      { name: "stopOnError", type: "boolean", description: "Stop polling on error", default: false },
+      { name: "maxPolls", type: "number", description: "Maximum poll count (null = infinite)", default: null }
+    ]
+  }
+};
+var ASYNC_BEHAVIORS = [
+  LOADING_BEHAVIOR,
+  FETCH_BEHAVIOR,
+  SUBMIT_BEHAVIOR,
+  RETRY_BEHAVIOR,
+  POLL_BEHAVIOR
+];
+
+// behaviors/feedback.ts
+var NOTIFICATION_BEHAVIOR = {
+  name: "std/Notification",
+  category: "feedback",
+  description: "Toast notification with auto-dismiss",
+  suggestedFor: [
+    "Success messages",
+    "Error alerts",
+    "Status updates",
+    "User feedback"
+  ],
+  dataEntities: [
+    {
+      name: "NotificationState",
+      runtime: true,
+      singleton: true,
+      fields: [
+        { name: "notifications", type: "array", default: [] },
+        { name: "currentId", type: "number", default: 0 }
+      ]
+    }
+  ],
+  stateMachine: {
+    initial: "Hidden",
+    states: [
+      { name: "Hidden", isInitial: true },
+      { name: "Visible" },
+      { name: "Dismissing" }
+    ],
+    events: [
+      { key: "SHOW" },
+      { key: "HIDE" },
+      { key: "DISMISS" },
+      { key: "AUTO_DISMISS" }
+    ],
+    transitions: [
+      {
+        from: "*",
+        event: "SHOW",
+        effects: [
+          [
+            "let",
+            [["id", ["+", "@entity.currentId", 1]]],
+            [
+              "do",
+              ["set", "@entity.currentId", "@id"],
+              [
+                "set",
+                "@entity.notifications",
+                ["array/append", "@entity.notifications", {
+                  id: "@id",
+                  type: "@payload.type",
+                  message: "@payload.message",
+                  title: "@payload.title"
+                }]
+              ],
+              [
+                "when",
+                [">", "@config.autoDismissMs", 0],
+                ["async/delay", "@config.autoDismissMs", ["emit", "AUTO_DISMISS", { id: "@id" }]]
+              ]
+            ]
+          ]
+        ]
+      },
+      {
+        event: "DISMISS",
+        effects: [
+          [
+            "set",
+            "@entity.notifications",
+            ["array/filter", "@entity.notifications", ["fn", "n", ["!=", "@n.id", "@payload.id"]]]
+          ]
+        ]
+      },
+      {
+        event: "AUTO_DISMISS",
+        effects: [
+          [
+            "set",
+            "@entity.notifications",
+            ["array/filter", "@entity.notifications", ["fn", "n", ["!=", "@n.id", "@payload.id"]]]
+          ]
+        ]
+      },
+      {
+        event: "HIDE",
+        effects: [
+          ["set", "@entity.notifications", []]
+        ]
+      }
+    ]
+  },
+  configSchema: {
+    required: [],
+    optional: [
+      { name: "autoDismissMs", type: "number", description: "Auto dismiss delay (0 = no auto)", default: 5e3 },
+      { name: "position", type: "string", description: "Toast position", default: "top-right", enum: ["top-left", "top-center", "top-right", "bottom-left", "bottom-center", "bottom-right"] },
+      { name: "maxVisible", type: "number", description: "Maximum visible notifications", default: 5 }
+    ]
+  }
+};
+var CONFIRMATION_BEHAVIOR = {
+  name: "std/Confirmation",
+  category: "feedback",
+  description: "Confirmation dialog with confirm/cancel actions",
+  suggestedFor: [
+    "Delete confirmation",
+    "Destructive actions",
+    "Important decisions",
+    "Exit warnings"
+  ],
+  dataEntities: [
+    {
+      name: "ConfirmationState",
+      runtime: true,
+      singleton: true,
+      fields: [
+        { name: "title", type: "string", default: "" },
+        { name: "message", type: "string", default: "" },
+        { name: "pendingAction", type: "object", default: null }
+      ]
+    }
+  ],
+  stateMachine: {
+    initial: "Closed",
+    states: [
+      { name: "Closed", isInitial: true },
+      { name: "Open" }
+    ],
+    events: [
+      { key: "REQUEST" },
+      { key: "CONFIRM" },
+      { key: "CANCEL" }
+    ],
+    transitions: [
+      {
+        from: "Closed",
+        to: "Open",
+        event: "REQUEST",
+        effects: [
+          ["set", "@entity.title", "@payload.title"],
+          ["set", "@entity.message", "@payload.message"],
+          ["set", "@entity.pendingAction", "@payload.onConfirm"],
+          ["render-ui", "modal", {
+            type: "confirmation",
+            title: "@entity.title",
+            message: "@entity.message",
+            confirmLabel: "@config.confirmLabel",
+            cancelLabel: "@config.cancelLabel",
+            confirmVariant: "@config.confirmVariant"
+          }]
+        ]
+      },
+      {
+        from: "Open",
+        to: "Closed",
+        event: "CONFIRM",
+        effects: [
+          ["render-ui", "modal", null],
+          ["when", "@entity.pendingAction", ["emit", "@entity.pendingAction.event", "@entity.pendingAction.payload"]],
+          ["set", "@entity.pendingAction", null]
+        ]
+      },
+      {
+        from: "Open",
+        to: "Closed",
+        event: "CANCEL",
+        effects: [
+          ["render-ui", "modal", null],
+          ["set", "@entity.pendingAction", null]
+        ]
+      }
+    ]
+  },
+  configSchema: {
+    required: [],
+    optional: [
+      { name: "confirmLabel", type: "string", description: "Confirm button label", default: "Confirm" },
+      { name: "cancelLabel", type: "string", description: "Cancel button label", default: "Cancel" },
+      { name: "confirmVariant", type: "string", description: "Confirm button variant", default: "primary", enum: ["primary", "danger", "warning"] }
+    ]
+  }
+};
+var UNDO_BEHAVIOR = {
+  name: "std/Undo",
+  category: "feedback",
+  description: "Undo/redo stack for reversible actions",
+  suggestedFor: [
+    "Document editing",
+    "Form changes",
+    "Canvas operations",
+    "Reversible actions"
+  ],
+  dataEntities: [
+    {
+      name: "UndoState",
+      runtime: true,
+      singleton: true,
+      fields: [
+        { name: "undoStack", type: "array", default: [] },
+        { name: "redoStack", type: "array", default: [] }
+      ]
+    }
+  ],
+  stateMachine: {
+    initial: "Ready",
+    states: [
+      { name: "Ready", isInitial: true }
+    ],
+    events: [
+      { key: "PUSH" },
+      { key: "UNDO" },
+      { key: "REDO" },
+      { key: "CLEAR" }
+    ],
+    transitions: [
+      {
+        event: "PUSH",
+        effects: [
+          [
+            "set",
+            "@entity.undoStack",
+            [
+              "array/slice",
+              ["array/prepend", "@entity.undoStack", {
+                action: "@payload.action",
+                data: "@payload.data",
+                reverseAction: "@payload.reverseAction",
+                reverseData: "@payload.reverseData",
+                description: "@payload.description"
+              }],
+              0,
+              "@config.maxHistory"
+            ]
+          ],
+          ["set", "@entity.redoStack", []],
+          [
+            "when",
+            "@config.showToast",
+            ["emit", "NOTIFY", {
+              type: "info",
+              message: ["str/concat", "@payload.description", " - Click to undo"],
+              action: { label: "Undo", event: "UNDO" }
+            }]
+          ]
+        ]
+      },
+      {
+        event: "UNDO",
+        guard: [">", ["array/len", "@entity.undoStack"], 0],
+        effects: [
+          [
+            "let",
+            [["action", ["array/first", "@entity.undoStack"]]],
+            [
+              "do",
+              ["set", "@entity.undoStack", ["array/slice", "@entity.undoStack", 1]],
+              ["set", "@entity.redoStack", ["array/prepend", "@entity.redoStack", "@action"]],
+              ["emit", "@action.reverseAction", "@action.reverseData"]
+            ]
+          ]
+        ]
+      },
+      {
+        event: "REDO",
+        guard: [">", ["array/len", "@entity.redoStack"], 0],
+        effects: [
+          [
+            "let",
+            [["action", ["array/first", "@entity.redoStack"]]],
+            [
+              "do",
+              ["set", "@entity.redoStack", ["array/slice", "@entity.redoStack", 1]],
+              ["set", "@entity.undoStack", ["array/prepend", "@entity.undoStack", "@action"]],
+              ["emit", "@action.action", "@action.data"]
+            ]
+          ]
+        ]
+      },
+      {
+        event: "CLEAR",
+        effects: [
+          ["set", "@entity.undoStack", []],
+          ["set", "@entity.redoStack", []]
+        ]
+      }
+    ]
+  },
+  configSchema: {
+    required: [],
+    optional: [
+      { name: "maxHistory", type: "number", description: "Maximum undo history", default: 50 },
+      { name: "showToast", type: "boolean", description: "Show undo toast", default: true },
+      { name: "toastDurationMs", type: "number", description: "Toast display duration", default: 5e3 }
+    ]
+  }
+};
+var FEEDBACK_BEHAVIORS = [
+  NOTIFICATION_BEHAVIOR,
+  CONFIRMATION_BEHAVIOR,
+  UNDO_BEHAVIOR
+];
+
+// behaviors/game-core.ts
+var GAME_LOOP_BEHAVIOR = {
+  name: "std/GameLoop",
+  category: "game-core",
+  description: "Master game loop coordinator running at 60fps",
+  suggestedFor: [
+    "All real-time games",
+    "Platformers",
+    "Action games",
+    "Endless runners"
+  ],
+  dataEntities: [
+    {
+      name: "GameLoopState",
+      runtime: true,
+      singleton: true,
+      fields: [
+        { name: "frameCount", type: "number", default: 0 },
+        { name: "deltaTime", type: "number", default: 16 },
+        { name: "elapsedTime", type: "number", default: 0 }
+      ]
+    }
+  ],
+  stateMachine: {
+    initial: "Stopped",
+    states: [
+      { name: "Stopped", isInitial: true },
+      { name: "Running" },
+      { name: "Paused" }
+    ],
+    events: [
+      { key: "START" },
+      { key: "STOP" },
+      { key: "PAUSE" },
+      { key: "RESUME" },
+      { key: "TICK" }
+    ],
+    transitions: [
+      {
+        from: "Stopped",
+        to: "Running",
+        event: "START",
+        effects: [
+          ["set", "@entity.frameCount", 0],
+          ["set", "@entity.elapsedTime", 0]
+        ]
+      },
+      {
+        from: "Running",
+        to: "Paused",
+        event: "PAUSE",
+        effects: []
+      },
+      {
+        from: "Paused",
+        to: "Running",
+        event: "RESUME",
+        effects: []
+      },
+      {
+        from: ["Running", "Paused"],
+        to: "Stopped",
+        event: "STOP",
+        effects: []
+      }
+    ]
+  },
+  ticks: [
+    {
+      name: "GameTick",
+      interval: "frame",
+      guard: ["=", "@state", "Running"],
+      effects: [
+        ["set", "@entity.frameCount", ["+", "@entity.frameCount", 1]],
+        ["set", "@entity.elapsedTime", ["+", "@entity.elapsedTime", "@entity.deltaTime"]],
+        ["emit", "GAME_TICK", { frame: "@entity.frameCount", delta: "@entity.deltaTime" }]
+      ]
+    }
+  ],
+  configSchema: {
+    required: [],
+    optional: [
+      { name: "targetFps", type: "number", description: "Target frames per second", default: 60 },
+      { name: "fixedTimestep", type: "boolean", description: "Use fixed timestep", default: true }
+    ]
+  }
+};
+var PHYSICS_2D_BEHAVIOR = {
+  name: "std/Physics2D",
+  category: "game-core",
+  description: "2D physics with gravity, velocity, and friction",
+  suggestedFor: [
+    "Platformer characters",
+    "Falling objects",
+    "Projectiles",
+    "Any entity affected by gravity"
+  ],
+  requiredFields: [
+    { name: "x", type: "number", description: "Entity X position" },
+    { name: "y", type: "number", description: "Entity Y position" }
+  ],
+  dataEntities: [
+    {
+      name: "Physics2DState",
+      runtime: true,
+      fields: [
+        { name: "vx", type: "number", default: 0 },
+        { name: "vy", type: "number", default: 0 },
+        { name: "isGrounded", type: "boolean", default: false }
+      ]
+    }
+  ],
+  stateMachine: {
+    initial: "Active",
+    states: [
+      { name: "Active", isInitial: true },
+      { name: "Frozen" }
+    ],
+    events: [
+      { key: "INIT" },
+      { key: "APPLY_FORCE" },
+      { key: "GROUND_HIT" },
+      { key: "FREEZE" },
+      { key: "UNFREEZE" }
+    ],
+    transitions: [
+      {
+        from: "*",
+        event: "INIT",
+        effects: [
+          ["set", "@entity.vx", 0],
+          ["set", "@entity.vy", 0],
+          ["set", "@entity.isGrounded", false]
+        ]
+      },
+      {
+        from: "Active",
+        event: "APPLY_FORCE",
+        effects: [
+          ["set", "@entity.vx", ["+", "@entity.vx", "@payload.fx"]],
+          ["set", "@entity.vy", ["+", "@entity.vy", "@payload.fy"]]
+        ]
+      },
+      {
+        from: "Active",
+        event: "GROUND_HIT",
+        effects: [
+          ["set", "@entity.isGrounded", true],
+          ["set", "@entity.vy", 0],
+          ["set", "@entity.vx", ["*", "@entity.vx", "@config.friction"]]
+        ]
+      },
+      {
+        from: "Active",
+        to: "Frozen",
+        event: "FREEZE",
+        effects: []
+      },
+      {
+        from: "Frozen",
+        to: "Active",
+        event: "UNFREEZE",
+        effects: []
+      }
+    ]
+  },
+  ticks: [
+    {
+      name: "ApplyGravity",
+      interval: "frame",
+      guard: ["and", ["=", "@state", "Active"], ["not", "@entity.isGrounded"]],
+      effects: [
+        ["set", "@entity.vy", ["math/min", "@config.maxVelocityY", ["+", "@entity.vy", "@config.gravity"]]]
+      ]
+    },
+    {
+      name: "ApplyVelocity",
+      interval: "frame",
+      guard: ["=", "@state", "Active"],
+      effects: [
+        ["set", "@entity.vx", ["*", "@entity.vx", "@config.airResistance"]],
+        ["set", "@entity.x", ["+", "@entity.x", "@entity.vx"]],
+        ["set", "@entity.y", ["+", "@entity.y", "@entity.vy"]]
+      ]
+    }
+  ],
+  configSchema: {
+    required: [],
+    optional: [
+      { name: "gravity", type: "number", description: "Gravity acceleration (pixels/frame\xB2)", default: 0.5 },
+      { name: "maxVelocityY", type: "number", description: "Terminal velocity", default: 15 },
+      { name: "friction", type: "number", description: "Ground friction (0-1)", default: 0.8 },
+      { name: "airResistance", type: "number", description: "Air resistance (0-1)", default: 0.99 }
+    ]
+  }
+};
+var INPUT_BEHAVIOR = {
+  name: "std/Input",
+  category: "game-core",
+  description: "Unified keyboard and touch input state management",
+  suggestedFor: [
+    "All interactive games",
+    "Player controls",
+    "Menu navigation"
+  ],
+  dataEntities: [
+    {
+      name: "InputState",
+      runtime: true,
+      singleton: true,
+      fields: [
+        { name: "left", type: "boolean", default: false },
+        { name: "right", type: "boolean", default: false },
+        { name: "up", type: "boolean", default: false },
+        { name: "down", type: "boolean", default: false },
+        { name: "jump", type: "boolean", default: false },
+        { name: "action", type: "boolean", default: false },
+        { name: "pause", type: "boolean", default: false }
+      ]
+    }
+  ],
+  stateMachine: {
+    initial: "Ready",
+    states: [
+      { name: "Ready", isInitial: true }
+    ],
+    events: [
+      { key: "KEY_DOWN" },
+      { key: "KEY_UP" },
+      { key: "TOUCH_START" },
+      { key: "TOUCH_END" },
+      { key: "RESET" }
+    ],
+    transitions: [
+      {
+        event: "KEY_DOWN",
+        effects: [
+          [
+            "if",
+            ["or", ["=", "@payload.key", "ArrowLeft"], ["=", "@payload.key", "a"]],
+            ["set", "@entity.left", true]
+          ],
+          [
+            "if",
+            ["or", ["=", "@payload.key", "ArrowRight"], ["=", "@payload.key", "d"]],
+            ["set", "@entity.right", true]
+          ],
+          [
+            "if",
+            ["or", ["=", "@payload.key", "ArrowUp"], ["=", "@payload.key", "w"]],
+            ["set", "@entity.up", true]
+          ],
+          [
+            "if",
+            ["or", ["=", "@payload.key", "ArrowDown"], ["=", "@payload.key", "s"]],
+            ["set", "@entity.down", true]
+          ],
+          [
+            "if",
+            ["=", "@payload.key", " "],
+            ["set", "@entity.jump", true]
+          ],
+          [
+            "if",
+            ["or", ["=", "@payload.key", "Enter"], ["=", "@payload.key", "e"]],
+            ["set", "@entity.action", true]
+          ],
+          [
+            "if",
+            ["or", ["=", "@payload.key", "Escape"], ["=", "@payload.key", "p"]],
+            ["set", "@entity.pause", true]
+          ]
+        ]
+      },
+      {
+        event: "KEY_UP",
+        effects: [
+          [
+            "if",
+            ["or", ["=", "@payload.key", "ArrowLeft"], ["=", "@payload.key", "a"]],
+            ["set", "@entity.left", false]
+          ],
+          [
+            "if",
+            ["or", ["=", "@payload.key", "ArrowRight"], ["=", "@payload.key", "d"]],
+            ["set", "@entity.right", false]
+          ],
+          [
+            "if",
+            ["or", ["=", "@payload.key", "ArrowUp"], ["=", "@payload.key", "w"]],
+            ["set", "@entity.up", false]
+          ],
+          [
+            "if",
+            ["or", ["=", "@payload.key", "ArrowDown"], ["=", "@payload.key", "s"]],
+            ["set", "@entity.down", false]
+          ],
+          [
+            "if",
+            ["=", "@payload.key", " "],
+            ["set", "@entity.jump", false]
+          ],
+          [
+            "if",
+            ["or", ["=", "@payload.key", "Enter"], ["=", "@payload.key", "e"]],
+            ["set", "@entity.action", false]
+          ],
+          [
+            "if",
+            ["or", ["=", "@payload.key", "Escape"], ["=", "@payload.key", "p"]],
+            ["set", "@entity.pause", false]
+          ]
+        ]
+      },
+      {
+        event: "RESET",
+        effects: [
+          ["set", "@entity.left", false],
+          ["set", "@entity.right", false],
+          ["set", "@entity.up", false],
+          ["set", "@entity.down", false],
+          ["set", "@entity.jump", false],
+          ["set", "@entity.action", false],
+          ["set", "@entity.pause", false]
+        ]
+      }
+    ]
+  },
+  configSchema: {
+    required: [],
+    optional: [
+      { name: "keyMap", type: "object", description: "Key to action mapping", default: {} }
+    ]
+  }
+};
+var COLLISION_BEHAVIOR = {
+  name: "std/Collision",
+  category: "game-core",
+  description: "Collision detection and response configuration",
+  suggestedFor: [
+    "Solid platforms",
+    "Trigger zones",
+    "Collectibles",
+    "Hazards"
+  ],
+  dataEntities: [
+    {
+      name: "CollisionState",
+      runtime: true,
+      fields: [
+        { name: "isColliding", type: "boolean", default: false },
+        { name: "collidingWith", type: "array", default: [] }
+      ]
+    }
+  ],
+  stateMachine: {
+    initial: "Active",
+    states: [
+      { name: "Active", isInitial: true },
+      { name: "Disabled" }
+    ],
+    events: [
+      { key: "COLLISION" },
+      { key: "TRIGGER_ENTER" },
+      { key: "TRIGGER_EXIT" },
+      { key: "ENABLE" },
+      { key: "DISABLE" }
+    ],
+    transitions: [
+      {
+        from: "Active",
+        event: "COLLISION",
+        effects: [
+          ["set", "@entity.isColliding", true],
+          ["set", "@entity.collidingWith", ["array/append", "@entity.collidingWith", "@payload.entityId"]],
+          [
+            "if",
+            "@config.onCollision",
+            ["emit", "@config.onCollision", { entityId: "@payload.entityId", side: "@payload.side" }]
+          ]
+        ]
+      },
+      {
+        from: "Active",
+        event: "TRIGGER_ENTER",
+        effects: [
+          [
+            "if",
+            "@config.onTrigger",
+            ["emit", "@config.onTrigger", { entityId: "@payload.entityId", action: "enter" }]
+          ]
+        ]
+      },
+      {
+        from: "Active",
+        event: "TRIGGER_EXIT",
+        effects: [
+          ["set", "@entity.collidingWith", ["array/filter", "@entity.collidingWith", ["fn", "id", ["!=", "@id", "@payload.entityId"]]]],
+          [
+            "if",
+            ["=", ["array/len", "@entity.collidingWith"], 0],
+            ["set", "@entity.isColliding", false]
+          ]
+        ]
+      },
+      {
+        from: "Active",
+        to: "Disabled",
+        event: "DISABLE",
+        effects: [
+          ["set", "@entity.isColliding", false],
+          ["set", "@entity.collidingWith", []]
+        ]
+      },
+      {
+        from: "Disabled",
+        to: "Active",
+        event: "ENABLE",
+        effects: []
+      }
+    ]
+  },
+  configSchema: {
+    required: [],
+    optional: [
+      { name: "type", type: "string", description: "Collision type", default: "solid", enum: ["solid", "trigger"] },
+      { name: "layer", type: "string", description: "Collision layer", default: "default" },
+      { name: "collidesWith", type: "array", description: "Layers to collide with", default: ["default"] },
+      { name: "onCollision", type: "event", description: "Event to emit on collision" },
+      { name: "onTrigger", type: "event", description: "Event to emit on trigger" }
+    ]
+  }
+};
+var GAME_CORE_BEHAVIORS = [
+  GAME_LOOP_BEHAVIOR,
+  PHYSICS_2D_BEHAVIOR,
+  INPUT_BEHAVIOR,
+  COLLISION_BEHAVIOR
+];
+
+// behaviors/game-entity.ts
+var HEALTH_BEHAVIOR = {
+  name: "std/Health",
+  category: "game-entity",
+  description: "Entity health with damage, healing, invulnerability, and death",
+  suggestedFor: [
+    "Player characters",
+    "Enemies",
+    "Destructible objects",
+    "Bosses"
+  ],
+  dataEntities: [
+    {
+      name: "HealthState",
+      runtime: true,
+      fields: [
+        { name: "currentHealth", type: "number", default: 100 },
+        { name: "maxHealth", type: "number", default: 100 },
+        { name: "isInvulnerable", type: "boolean", default: false },
+        { name: "lastDamageTime", type: "number", default: 0 }
+      ]
+    }
+  ],
+  stateMachine: {
+    initial: "Alive",
+    states: [
+      { name: "Alive", isInitial: true },
+      { name: "Damaged" },
+      { name: "Invulnerable" },
+      { name: "Dead" }
+    ],
+    events: [
+      { key: "INIT" },
+      { key: "DAMAGE" },
+      { key: "HEAL" },
+      { key: "DIE" },
+      { key: "RESPAWN" },
+      { key: "INVULNERABILITY_END" }
+    ],
+    transitions: [
+      {
+        from: "*",
+        to: "Alive",
+        event: "INIT",
+        effects: [
+          ["set", "@entity.currentHealth", "@config.maxHealth"],
+          ["set", "@entity.maxHealth", "@config.maxHealth"],
+          ["set", "@entity.isInvulnerable", false],
+          ["render", "hud.health", "health-bar", {
+            current: "@entity.currentHealth",
+            max: "@entity.maxHealth"
+          }]
+        ]
+      },
+      {
+        from: "Alive",
+        to: "Damaged",
+        event: "DAMAGE",
+        guard: ["not", "@entity.isInvulnerable"],
+        effects: [
+          ["set", "@entity.currentHealth", ["math/max", 0, ["-", "@entity.currentHealth", "@payload.amount"]]],
+          ["set", "@entity.lastDamageTime", "@now"],
+          [
+            "if",
+            ["<=", "@entity.currentHealth", 0],
+            ["emit", "DIE"],
+            [
+              "do",
+              ["set", "@entity.isInvulnerable", true],
+              ["render", "entity.flash", "damage-flash", {}]
+            ]
+          ]
+        ]
+      },
+      {
+        from: ["Damaged", "Invulnerable"],
+        to: "Alive",
+        event: "INVULNERABILITY_END",
+        effects: [
+          ["set", "@entity.isInvulnerable", false]
+        ]
+      },
+      {
+        from: ["Alive", "Damaged", "Invulnerable"],
+        event: "HEAL",
+        effects: [
+          ["set", "@entity.currentHealth", ["math/min", "@entity.maxHealth", ["+", "@entity.currentHealth", "@payload.amount"]]],
+          ["render", "entity.effect", "heal-effect", {}]
+        ]
+      },
+      {
+        from: ["Alive", "Damaged", "Invulnerable"],
+        to: "Dead",
+        event: "DIE",
+        effects: [
+          ["set", "@entity.currentHealth", 0],
+          ["emit", "@config.onDeath", { entityId: "@entity.id" }],
+          ["render", "entity.sprite", "death-animation", {}]
+        ]
+      },
+      {
+        from: "Dead",
+        to: "Alive",
+        event: "RESPAWN",
+        effects: [
+          ["emit", "INIT"]
+        ]
+      }
+    ]
+  },
+  ticks: [
+    {
+      name: "InvulnerabilityTimer",
+      interval: "frame",
+      guard: ["and", "@entity.isInvulnerable", [">", ["-", "@now", "@entity.lastDamageTime"], "@config.invulnerabilityTime"]],
+      effects: [
+        ["emit", "INVULNERABILITY_END"]
+      ]
+    }
+  ],
+  configSchema: {
+    required: [
+      { name: "maxHealth", type: "number", description: "Maximum health points" }
+    ],
+    optional: [
+      { name: "invulnerabilityTime", type: "number", description: "Invulnerability duration after damage (ms)", default: 500 },
+      { name: "onDeath", type: "event", description: "Event to emit on death", default: "ENTITY_DIED" },
+      { name: "showHealthBar", type: "boolean", description: "Render health bar", default: true }
+    ]
+  }
+};
+var SCORE_BEHAVIOR = {
+  name: "std/Score",
+  category: "game-entity",
+  description: "Score tracking with points, combos, and multipliers",
+  suggestedFor: [
+    "Arcade games",
+    "Puzzle games",
+    "Platformers with collectibles",
+    "Competitive games"
+  ],
+  dataEntities: [
+    {
+      name: "ScoreState",
+      runtime: true,
+      singleton: true,
+      fields: [
+        { name: "currentScore", type: "number", default: 0 },
+        { name: "highScore", type: "number", default: 0 },
+        { name: "comboCount", type: "number", default: 0 },
+        { name: "multiplier", type: "number", default: 1 },
+        { name: "lastScoreTime", type: "number", default: 0 }
+      ]
+    }
+  ],
+  stateMachine: {
+    initial: "Active",
+    states: [
+      { name: "Active", isInitial: true }
+    ],
+    events: [
+      { key: "INIT" },
+      { key: "ADD_POINTS" },
+      { key: "COMBO_HIT" },
+      { key: "COMBO_BREAK" },
+      { key: "RESET" },
+      { key: "SAVE_HIGH_SCORE" }
+    ],
+    transitions: [
+      {
+        from: "*",
+        event: "INIT",
+        effects: [
+          ["set", "@entity.currentScore", 0],
+          ["set", "@entity.comboCount", 0],
+          ["set", "@entity.multiplier", 1],
+          ["render", "hud.score", "score-display", {
+            score: "@entity.currentScore",
+            highScore: "@entity.highScore",
+            combo: "@entity.comboCount",
+            multiplier: "@entity.multiplier"
+          }]
+        ]
+      },
+      {
+        event: "ADD_POINTS",
+        effects: [
+          ["set", "@entity.currentScore", ["+", "@entity.currentScore", ["*", "@payload.points", "@entity.multiplier"]]],
+          ["set", "@entity.lastScoreTime", "@now"],
+          ["render", "entity.effect", "score-popup", {
+            points: ["*", "@payload.points", "@entity.multiplier"],
+            position: "@payload.position"
+          }]
+        ]
+      },
+      {
+        event: "COMBO_HIT",
+        effects: [
+          ["set", "@entity.comboCount", ["+", "@entity.comboCount", 1]],
+          ["set", "@entity.multiplier", ["math/min", "@config.maxMultiplier", ["+", 1, ["/", "@entity.comboCount", 5]]]],
+          ["set", "@entity.lastScoreTime", "@now"]
+        ]
+      },
+      {
+        event: "COMBO_BREAK",
+        effects: [
+          ["set", "@entity.comboCount", 0],
+          ["set", "@entity.multiplier", 1]
+        ]
+      },
+      {
+        event: "RESET",
+        effects: [
+          [
+            "if",
+            [">", "@entity.currentScore", "@entity.highScore"],
+            ["set", "@entity.highScore", "@entity.currentScore"]
+          ],
+          ["emit", "INIT"]
+        ]
+      },
+      {
+        event: "SAVE_HIGH_SCORE",
+        guard: [">", "@entity.currentScore", "@entity.highScore"],
+        effects: [
+          ["set", "@entity.highScore", "@entity.currentScore"],
+          ["persist", "save", "HighScore", { score: "@entity.highScore" }]
+        ]
+      }
+    ]
+  },
+  ticks: [
+    {
+      name: "ComboTimeout",
+      interval: "frame",
+      guard: ["and", [">", "@entity.comboCount", 0], [">", ["-", "@now", "@entity.lastScoreTime"], "@config.comboTimeWindow"]],
+      effects: [
+        ["emit", "COMBO_BREAK"]
+      ]
+    }
+  ],
+  configSchema: {
+    required: [],
+    optional: [
+      { name: "comboTimeWindow", type: "number", description: "Time window for combos (ms)", default: 2e3 },
+      { name: "maxMultiplier", type: "number", description: "Maximum combo multiplier", default: 10 },
+      { name: "persistHighScore", type: "boolean", description: "Save high score to storage", default: true }
+    ]
+  }
+};
+var MOVEMENT_BEHAVIOR = {
+  name: "std/Movement",
+  category: "game-entity",
+  description: "Entity movement with speed and direction",
+  suggestedFor: [
+    "Player characters",
+    "NPCs",
+    "Enemies",
+    "Moving platforms"
+  ],
+  requiredFields: [
+    { name: "x", type: "number", description: "Entity X position" },
+    { name: "y", type: "number", description: "Entity Y position" }
+  ],
+  dataEntities: [
+    {
+      name: "MovementState",
+      runtime: true,
+      fields: [
+        { name: "direction", type: "number", default: 0 },
+        { name: "facingRight", type: "boolean", default: true },
+        { name: "canJump", type: "boolean", default: true }
+      ]
+    }
+  ],
+  stateMachine: {
+    initial: "Idle",
+    states: [
+      { name: "Idle", isInitial: true },
+      { name: "Moving" },
+      { name: "Jumping" },
+      { name: "Falling" }
+    ],
+    events: [
+      { key: "MOVE" },
+      { key: "STOP" },
+      { key: "JUMP" },
+      { key: "LAND" }
+    ],
+    transitions: [
+      {
+        from: "Idle",
+        to: "Moving",
+        event: "MOVE",
+        effects: [
+          ["set", "@entity.direction", "@payload.direction"],
+          [
+            "if",
+            [">", "@payload.direction", 0],
+            ["set", "@entity.facingRight", true]
+          ],
+          [
+            "if",
+            ["<", "@payload.direction", 0],
+            ["set", "@entity.facingRight", false]
+          ]
+        ]
+      },
+      {
+        from: "Moving",
+        event: "MOVE",
+        effects: [
+          ["set", "@entity.direction", "@payload.direction"],
+          [
+            "if",
+            [">", "@payload.direction", 0],
+            ["set", "@entity.facingRight", true]
+          ],
+          [
+            "if",
+            ["<", "@payload.direction", 0],
+            ["set", "@entity.facingRight", false]
+          ]
+        ]
+      },
+      {
+        from: "Moving",
+        to: "Idle",
+        event: "STOP",
+        effects: [
+          ["set", "@entity.direction", 0]
+        ]
+      },
+      {
+        from: ["Idle", "Moving"],
+        to: "Jumping",
+        event: "JUMP",
+        guard: "@entity.canJump",
+        effects: [
+          ["set", "@entity.canJump", false],
+          ["emit", "APPLY_FORCE", { fx: 0, fy: "@config.jumpForce" }]
+        ]
+      },
+      {
+        from: ["Jumping", "Falling"],
+        to: "Idle",
+        event: "LAND",
+        effects: [
+          ["set", "@entity.canJump", true],
+          [
+            "if",
+            ["!=", "@entity.direction", 0],
+            ["emit", "MOVE", { direction: "@entity.direction" }]
+          ]
+        ]
+      }
+    ]
+  },
+  ticks: [
+    {
+      name: "ApplyMovement",
+      interval: "frame",
+      guard: ["!=", "@entity.direction", 0],
+      effects: [
+        ["set", "@entity.x", ["+", "@entity.x", ["*", "@entity.direction", "@config.moveSpeed"]]]
+      ]
+    }
+  ],
+  configSchema: {
+    required: [],
+    optional: [
+      { name: "moveSpeed", type: "number", description: "Movement speed (pixels/frame)", default: 5 },
+      { name: "jumpForce", type: "number", description: "Jump velocity", default: -12 },
+      { name: "acceleration", type: "number", description: "Acceleration rate", default: 0.5 },
+      { name: "deceleration", type: "number", description: "Deceleration rate", default: 0.3 }
+    ]
+  }
+};
+var COMBAT_BEHAVIOR = {
+  name: "std/Combat",
+  category: "game-entity",
+  description: "Combat system with attacks, cooldowns, and hitboxes",
+  suggestedFor: [
+    "Fighting games",
+    "Action RPGs",
+    "Beat-em-ups",
+    "Boss encounters"
+  ],
+  dataEntities: [
+    {
+      name: "CombatState",
+      runtime: true,
+      fields: [
+        { name: "isAttacking", type: "boolean", default: false },
+        { name: "attackStartTime", type: "number", default: 0 },
+        { name: "hitEntities", type: "array", default: [] }
+      ]
+    }
+  ],
+  stateMachine: {
+    initial: "Ready",
+    states: [
+      { name: "Ready", isInitial: true },
+      { name: "Attacking" },
+      { name: "Cooldown" }
+    ],
+    events: [
+      { key: "ATTACK" },
+      { key: "ATTACK_END" },
+      { key: "HIT_CONNECT" },
+      { key: "COOLDOWN_END" }
+    ],
+    transitions: [
+      {
+        from: "Ready",
+        to: "Attacking",
+        event: "ATTACK",
+        effects: [
+          ["set", "@entity.isAttacking", true],
+          ["set", "@entity.attackStartTime", "@now"],
+          ["set", "@entity.hitEntities", []],
+          ["render", "entity.sprite", "attack-animation", {}],
+          ["render", "entity.hitbox", "hitbox", {
+            active: true,
+            offset: "@config.hitboxOffset",
+            size: "@config.hitboxSize"
+          }]
+        ]
+      },
+      {
+        from: "Attacking",
+        event: "HIT_CONNECT",
+        guard: ["not", ["array/includes", "@entity.hitEntities", "@payload.entityId"]],
+        effects: [
+          ["set", "@entity.hitEntities", ["array/append", "@entity.hitEntities", "@payload.entityId"]],
+          ["emit", "DAMAGE", { target: "@payload.entityId", amount: "@config.attackDamage" }],
+          ["render", "effect.impact", "hit-effect", { position: "@payload.position" }]
+        ]
+      },
+      {
+        from: "Attacking",
+        to: "Cooldown",
+        event: "ATTACK_END",
+        effects: [
+          ["set", "@entity.isAttacking", false],
+          ["render", "entity.hitbox", null]
+        ]
+      },
+      {
+        from: "Cooldown",
+        to: "Ready",
+        event: "COOLDOWN_END",
+        effects: []
+      }
+    ]
+  },
+  ticks: [
+    {
+      name: "AttackDuration",
+      interval: "frame",
+      guard: ["and", "@entity.isAttacking", [">", ["-", "@now", "@entity.attackStartTime"], "@config.attackDuration"]],
+      effects: [
+        ["emit", "ATTACK_END"]
+      ]
+    },
+    {
+      name: "CooldownTimer",
+      interval: "frame",
+      guard: ["and", ["=", "@state", "Cooldown"], [">", ["-", "@now", "@entity.attackStartTime"], ["+", "@config.attackDuration", "@config.cooldownDuration"]]],
+      effects: [
+        ["emit", "COOLDOWN_END"]
+      ]
+    }
+  ],
+  configSchema: {
+    required: [],
+    optional: [
+      { name: "attackDamage", type: "number", description: "Damage per attack", default: 10 },
+      { name: "attackDuration", type: "number", description: "Attack animation duration (ms)", default: 200 },
+      { name: "cooldownDuration", type: "number", description: "Cooldown between attacks (ms)", default: 300 },
+      { name: "hitboxOffset", type: "object", description: "Hitbox offset from entity", default: { x: 20, y: 0 } },
+      { name: "hitboxSize", type: "object", description: "Hitbox dimensions", default: { width: 30, height: 40 } }
+    ]
+  }
+};
+var INVENTORY_BEHAVIOR = {
+  name: "std/Inventory",
+  category: "game-entity",
+  description: "Item collection, storage, and usage",
+  suggestedFor: [
+    "RPGs",
+    "Adventure games",
+    "Survival games",
+    "Collectible-based games"
+  ],
+  dataEntities: [
+    {
+      name: "InventoryState",
+      runtime: true,
+      fields: [
+        { name: "items", type: "array", default: [] },
+        { name: "selectedSlot", type: "number", default: 0 },
+        { name: "isOpen", type: "boolean", default: false },
+        { name: "equipped", type: "object", default: {} }
+      ]
+    }
+  ],
+  stateMachine: {
+    initial: "Empty",
+    states: [
+      { name: "Empty", isInitial: true },
+      { name: "HasItems" },
+      { name: "Full" }
+    ],
+    events: [
+      { key: "COLLECT" },
+      { key: "USE" },
+      { key: "DROP" },
+      { key: "EQUIP" },
+      { key: "UNEQUIP" },
+      { key: "OPEN" },
+      { key: "CLOSE" },
+      { key: "INVENTORY_EMPTY" }
+    ],
+    transitions: [
+      {
+        from: ["Empty", "HasItems"],
+        to: "HasItems",
+        event: "COLLECT",
+        guard: ["<", ["array/len", "@entity.items"], "@config.maxSlots"],
+        effects: [
+          ["set", "@entity.items", ["array/append", "@entity.items", "@payload.item"]],
+          ["render", "effect.collect", "collect-effect", { item: "@payload.item" }],
+          ["notify", { type: "info", message: ["str/concat", "Collected ", "@payload.item.name"] }]
+        ]
+      },
+      {
+        from: "HasItems",
+        event: "USE",
+        effects: [
+          [
+            "let",
+            [["item", ["array/nth", "@entity.items", "@payload.slot"]]],
+            [
+              "if",
+              "@item.onUse",
+              ["emit", "@item.onUse", { item: "@item" }]
+            ],
+            [
+              "if",
+              "@item.consumable",
+              ["set", "@entity.items", ["array/filter", "@entity.items", ["fn", "i", "idx", ["!=", "@idx", "@payload.slot"]]]]
+            ]
+          ],
+          [
+            "if",
+            ["=", ["array/len", "@entity.items"], 0],
+            ["emit", "INVENTORY_EMPTY"]
+          ]
+        ]
+      },
+      {
+        from: "HasItems",
+        event: "DROP",
+        effects: [
+          [
+            "let",
+            [["item", ["array/nth", "@entity.items", "@payload.slot"]]],
+            ["set", "@entity.items", ["array/filter", "@entity.items", ["fn", "i", "idx", ["!=", "@idx", "@payload.slot"]]]],
+            ["emit", "ITEM_DROPPED", { item: "@item", position: { x: "@entity.x", y: "@entity.y" } }]
+          ],
+          [
+            "if",
+            ["=", ["array/len", "@entity.items"], 0],
+            ["emit", "INVENTORY_EMPTY"]
+          ]
+        ]
+      },
+      {
+        from: "HasItems",
+        to: "Empty",
+        event: "INVENTORY_EMPTY",
+        effects: []
+      },
+      {
+        event: "EQUIP",
+        effects: [
+          ["set", "@entity.equipped", ["object/set", "@entity.equipped", "@payload.slot", "@payload.item"]],
+          ["emit", "STATS_UPDATED", { equipped: "@entity.equipped" }]
+        ]
+      },
+      {
+        event: "UNEQUIP",
+        effects: [
+          ["set", "@entity.equipped", ["object/remove", "@entity.equipped", "@payload.slot"]],
+          ["emit", "STATS_UPDATED", { equipped: "@entity.equipped" }]
+        ]
+      },
+      {
+        event: "OPEN",
+        effects: [
+          ["set", "@entity.isOpen", true],
+          ["render", "overlay.inventory", "inventory-panel", {
+            items: "@entity.items",
+            selectedSlot: "@entity.selectedSlot",
+            equipped: "@entity.equipped",
+            maxSlots: "@config.maxSlots",
+            onUse: "USE",
+            onDrop: "DROP",
+            onEquip: "EQUIP",
+            onClose: "CLOSE"
+          }]
+        ]
+      },
+      {
+        event: "CLOSE",
+        effects: [
+          ["set", "@entity.isOpen", false],
+          ["render", "overlay.inventory", null]
+        ]
+      }
+    ]
+  },
+  configSchema: {
+    required: [],
+    optional: [
+      { name: "maxSlots", type: "number", description: "Maximum inventory slots", default: 20 },
+      { name: "stackable", type: "boolean", description: "Allow item stacking", default: true },
+      { name: "maxStack", type: "number", description: "Maximum stack size", default: 99 }
+    ]
+  }
+};
+var GAME_ENTITY_BEHAVIORS = [
+  HEALTH_BEHAVIOR,
+  SCORE_BEHAVIOR,
+  MOVEMENT_BEHAVIOR,
+  COMBAT_BEHAVIOR,
+  INVENTORY_BEHAVIOR
+];
+
+// behaviors/game-ui.ts
+var GAME_FLOW_BEHAVIOR = {
+  name: "std/GameFlow",
+  category: "game-ui",
+  description: "Master game flow: menu, play, pause, game over, victory",
+  suggestedFor: [
+    "All games",
+    "Game state management",
+    "Menu systems",
+    "Win/lose conditions"
+  ],
+  dataEntities: [
+    {
+      name: "GameFlowState",
+      runtime: true,
+      singleton: true,
+      fields: [
+        { name: "playTime", type: "number", default: 0 },
+        { name: "attempts", type: "number", default: 0 },
+        { name: "lastState", type: "string", default: "Menu" }
+      ]
+    }
+  ],
+  stateMachine: {
+    initial: "Menu",
+    states: [
+      { name: "Menu", isInitial: true },
+      { name: "Playing" },
+      { name: "Paused" },
+      { name: "GameOver" },
+      { name: "Victory" }
+    ],
+    events: [
+      { key: "START" },
+      { key: "PAUSE" },
+      { key: "RESUME" },
+      { key: "GAME_OVER" },
+      { key: "VICTORY" },
+      { key: "RESTART" },
+      { key: "QUIT" }
+    ],
+    transitions: [
+      {
+        from: "*",
+        to: "Menu",
+        event: "QUIT",
+        effects: [
+          ["emit", "STOP"],
+          ["render", "screen", "game-menu", {
+            title: "@config.title",
+            onStart: "START"
+          }]
+        ]
+      },
+      {
+        from: "Menu",
+        to: "Playing",
+        event: "START",
+        effects: [
+          ["set", "@entity.attempts", ["+", "@entity.attempts", 1]],
+          ["set", "@entity.playTime", 0],
+          ["emit", "GAME_LOOP_START"],
+          ["render", "screen", null],
+          ["render", "canvas", "game-canvas", {}]
+        ]
+      },
+      {
+        from: "Playing",
+        to: "Paused",
+        event: "PAUSE",
+        guard: "@config.allowPause",
+        effects: [
+          ["set", "@entity.lastState", "Playing"],
+          ["emit", "GAME_LOOP_PAUSE"],
+          ["render", "overlay", "game-pause-overlay", {
+            onResume: "RESUME",
+            onQuit: "QUIT",
+            playTime: "@entity.playTime"
+          }]
+        ]
+      },
+      {
+        from: "Paused",
+        to: "Playing",
+        event: "RESUME",
+        effects: [
+          ["emit", "GAME_LOOP_RESUME"],
+          ["render", "overlay", null]
+        ]
+      },
+      {
+        from: "Playing",
+        to: "GameOver",
+        event: "GAME_OVER",
+        effects: [
+          ["emit", "STOP"],
+          ["render", "overlay", "game-over-screen", {
+            victory: false,
+            playTime: "@entity.playTime",
+            attempts: "@entity.attempts",
+            onRestart: "RESTART",
+            onQuit: "QUIT"
+          }]
+        ]
+      },
+      {
+        from: "Playing",
+        to: "Victory",
+        event: "VICTORY",
+        effects: [
+          ["emit", "STOP"],
+          ["render", "overlay", "game-over-screen", {
+            victory: true,
+            playTime: "@entity.playTime",
+            attempts: "@entity.attempts",
+            onRestart: "RESTART",
+            onQuit: "QUIT"
+          }]
+        ]
+      },
+      {
+        from: ["GameOver", "Victory"],
+        to: "Playing",
+        event: "RESTART",
+        effects: [
+          ["render", "overlay", null],
+          ["emit", "GAME_RESET"],
+          ["emit", "START"]
+        ]
+      }
+    ]
+  },
+  configSchema: {
+    required: [],
+    optional: [
+      { name: "title", type: "string", description: "Game title", default: "Game" },
+      { name: "showMenu", type: "boolean", description: "Show main menu", default: true },
+      { name: "allowPause", type: "boolean", description: "Allow pausing", default: true }
+    ]
+  }
+};
+var DIALOGUE_BEHAVIOR = {
+  name: "std/Dialogue",
+  category: "game-ui",
+  description: "NPC dialogue system with branching conversations",
+  suggestedFor: [
+    "RPGs",
+    "Adventure games",
+    "Story-driven games",
+    "NPC interactions"
+  ],
+  dataEntities: [
+    {
+      name: "DialogueState",
+      runtime: true,
+      fields: [
+        { name: "dialogueTree", type: "array", default: [] },
+        { name: "currentNode", type: "number", default: 0 },
+        { name: "displayedText", type: "string", default: "" },
+        { name: "isTyping", type: "boolean", default: false },
+        { name: "speaker", type: "string", default: "" },
+        { name: "typeIndex", type: "number", default: 0 },
+        { name: "lastTypeTime", type: "number", default: 0 }
+      ]
+    }
+  ],
+  stateMachine: {
+    initial: "Hidden",
+    states: [
+      { name: "Hidden", isInitial: true },
+      { name: "Typing" },
+      { name: "Showing" },
+      { name: "Choice" }
+    ],
+    events: [
+      { key: "SHOW" },
+      { key: "NEXT" },
+      { key: "SELECT_CHOICE" },
+      { key: "SKIP" },
+      { key: "CLOSE" },
+      { key: "TYPE_CHAR" },
+      { key: "TYPE_COMPLETE" }
+    ],
+    transitions: [
+      {
+        from: "Hidden",
+        to: "Typing",
+        event: "SHOW",
+        effects: [
+          ["set", "@entity.dialogueTree", "@payload.dialogue"],
+          ["set", "@entity.currentNode", 0],
+          ["set", "@entity.isTyping", true],
+          ["set", "@entity.displayedText", ""],
+          ["set", "@entity.typeIndex", 0],
+          ["set", "@entity.lastTypeTime", "@now"],
+          ["emit", "GAME_PAUSE"],
+          ["render", "overlay.dialogue", "dialogue-box", {
+            speaker: "@entity.speaker",
+            text: "@entity.displayedText",
+            isTyping: "@entity.isTyping",
+            onNext: "NEXT",
+            onSkip: "SKIP"
+          }]
+        ]
+      },
+      {
+        from: "Typing",
+        event: "TYPE_CHAR",
+        effects: [
+          [
+            "let",
+            [["currentDialogue", ["array/nth", "@entity.dialogueTree", "@entity.currentNode"]]],
+            [
+              "do",
+              ["set", "@entity.typeIndex", ["+", "@entity.typeIndex", 1]],
+              ["set", "@entity.displayedText", ["str/slice", "@currentDialogue.text", 0, "@entity.typeIndex"]],
+              ["set", "@entity.lastTypeTime", "@now"]
+            ]
+          ]
+        ]
+      },
+      {
+        from: "Typing",
+        to: "Showing",
+        event: "TYPE_COMPLETE",
+        effects: [
+          ["set", "@entity.isTyping", false]
+        ]
+      },
+      {
+        from: "Typing",
+        to: "Showing",
+        event: "SKIP",
+        effects: [
+          [
+            "let",
+            [["currentDialogue", ["array/nth", "@entity.dialogueTree", "@entity.currentNode"]]],
+            [
+              "do",
+              ["set", "@entity.isTyping", false],
+              ["set", "@entity.displayedText", "@currentDialogue.text"]
+            ]
+          ]
+        ]
+      },
+      {
+        from: "Showing",
+        event: "NEXT",
+        guard: ["not", ["object/get", ["array/nth", "@entity.dialogueTree", "@entity.currentNode"], "choices"]],
+        effects: [
+          [
+            "if",
+            [">=", "@entity.currentNode", ["-", ["array/len", "@entity.dialogueTree"], 1]],
+            ["emit", "CLOSE"],
+            [
+              "do",
+              ["set", "@entity.currentNode", ["+", "@entity.currentNode", 1]],
+              ["set", "@entity.isTyping", true],
+              ["set", "@entity.displayedText", ""],
+              ["set", "@entity.typeIndex", 0]
+            ]
+          ]
+        ]
+      },
+      {
+        from: "Showing",
+        to: "Choice",
+        event: "NEXT",
+        guard: ["object/get", ["array/nth", "@entity.dialogueTree", "@entity.currentNode"], "choices"],
+        effects: [
+          [
+            "let",
+            [["currentDialogue", ["array/nth", "@entity.dialogueTree", "@entity.currentNode"]]],
+            ["render", "overlay.dialogue", "dialogue-box", {
+              choices: "@currentDialogue.choices",
+              onSelect: "SELECT_CHOICE"
+            }]
+          ]
+        ]
+      },
+      {
+        from: "Choice",
+        to: "Typing",
+        event: "SELECT_CHOICE",
+        effects: [
+          [
+            "let",
+            [["currentDialogue", ["array/nth", "@entity.dialogueTree", "@entity.currentNode"]]],
+            [
+              "let",
+              [["choice", ["array/nth", "@currentDialogue.choices", "@payload.index"]]],
+              [
+                "do",
+                [
+                  "if",
+                  "@choice.nextNode",
+                  ["set", "@entity.currentNode", "@choice.nextNode"],
+                  ["set", "@entity.currentNode", ["+", "@entity.currentNode", 1]]
+                ],
+                [
+                  "if",
+                  "@choice.effect",
+                  ["emit", "@choice.effect"]
+                ]
+              ]
+            ]
+          ],
+          ["set", "@entity.isTyping", true],
+          ["set", "@entity.displayedText", ""],
+          ["set", "@entity.typeIndex", 0]
+        ]
+      },
+      {
+        from: ["Typing", "Showing", "Choice"],
+        to: "Hidden",
+        event: "CLOSE",
+        effects: [
+          ["set", "@entity.dialogueTree", []],
+          ["set", "@entity.currentNode", 0],
+          ["emit", "GAME_RESUME"],
+          ["render", "overlay.dialogue", null]
+        ]
+      }
+    ]
+  },
+  ticks: [
+    {
+      name: "TypewriterEffect",
+      interval: "frame",
+      guard: ["and", "@entity.isTyping", [">", ["-", "@now", "@entity.lastTypeTime"], ["/", 1e3, "@config.typingSpeed"]]],
+      effects: [
+        [
+          "let",
+          [["currentDialogue", ["array/nth", "@entity.dialogueTree", "@entity.currentNode"]]],
+          [
+            "if",
+            ["<", "@entity.typeIndex", ["str/len", "@currentDialogue.text"]],
+            ["emit", "TYPE_CHAR"],
+            ["emit", "TYPE_COMPLETE"]
+          ]
+        ]
+      ]
+    }
+  ],
+  configSchema: {
+    required: [],
+    optional: [
+      { name: "typingSpeed", type: "number", description: "Characters per second", default: 30 },
+      { name: "autoAdvance", type: "boolean", description: "Auto-advance after typing", default: false },
+      { name: "autoAdvanceDelay", type: "number", description: "Delay before auto-advance (ms)", default: 2e3 },
+      { name: "showPortrait", type: "boolean", description: "Show speaker portrait", default: true }
+    ]
+  }
+};
+var LEVEL_PROGRESS_BEHAVIOR = {
+  name: "std/LevelProgress",
+  category: "game-ui",
+  description: "Level progression with unlock, selection, and completion tracking",
+  suggestedFor: [
+    "Level-based games",
+    "Puzzle games",
+    "Platformers with levels",
+    "Mobile games"
+  ],
+  dataEntities: [
+    {
+      name: "LevelProgressState",
+      runtime: true,
+      singleton: true,
+      fields: [
+        { name: "currentLevel", type: "number", default: 0 },
+        { name: "unlockedLevels", type: "array", default: [0] },
+        { name: "levelStars", type: "object", default: {} },
+        { name: "totalStars", type: "number", default: 0 }
+      ]
+    }
+  ],
+  stateMachine: {
+    initial: "Browsing",
+    states: [
+      { name: "Browsing", isInitial: true },
+      { name: "LevelLoading" },
+      { name: "InLevel" }
+    ],
+    events: [
+      { key: "INIT" },
+      { key: "SELECT_LEVEL" },
+      { key: "LEVEL_LOADED" },
+      { key: "COMPLETE_LEVEL" },
+      { key: "UNLOCK_LEVEL" },
+      { key: "BACK_TO_SELECT" }
+    ],
+    transitions: [
+      {
+        from: "*",
+        to: "Browsing",
+        event: "INIT",
+        effects: [
+          ["render", "screen", "level-select", {
+            levels: "@config.levels",
+            unlockedLevels: "@entity.unlockedLevels",
+            levelStars: "@entity.levelStars",
+            starsPerLevel: "@config.starsPerLevel",
+            totalStars: "@entity.totalStars",
+            onSelect: "SELECT_LEVEL"
+          }]
+        ]
+      },
+      {
+        from: "Browsing",
+        to: "LevelLoading",
+        event: "SELECT_LEVEL",
+        guard: ["array/includes", "@entity.unlockedLevels", "@payload.levelIndex"],
+        effects: [
+          ["set", "@entity.currentLevel", "@payload.levelIndex"],
+          ["render", "screen", "loading-screen", {
+            level: ["array/nth", "@config.levels", "@payload.levelIndex"]
+          }],
+          ["emit", "LOAD_LEVEL", { levelData: ["array/nth", "@config.levels", "@payload.levelIndex"] }]
+        ]
+      },
+      {
+        from: "LevelLoading",
+        to: "InLevel",
+        event: "LEVEL_LOADED",
+        effects: [
+          ["render", "screen", null],
+          ["emit", "START"]
+        ]
+      },
+      {
+        from: "InLevel",
+        event: "COMPLETE_LEVEL",
+        effects: [
+          ["set", "@entity.levelStars", [
+            "object/set",
+            "@entity.levelStars",
+            ["str/toString", "@entity.currentLevel"],
+            ["math/max", "@payload.stars", ["object/get", "@entity.levelStars", ["str/toString", "@entity.currentLevel"], 0]]
+          ]],
+          ["set", "@entity.totalStars", ["array/reduce", ["object/values", "@entity.levelStars"], ["fn", "sum", "v", ["+", "@sum", "@v"]], 0]],
+          [
+            "if",
+            ["and", "@config.unlockNext", ["<", "@entity.currentLevel", ["-", ["array/len", "@config.levels"], 1]]],
+            ["emit", "UNLOCK_LEVEL", { levelIndex: ["+", "@entity.currentLevel", 1] }]
+          ],
+          [
+            "if",
+            "@config.persistProgress",
+            ["persist", "save", "LevelProgress", {
+              unlockedLevels: "@entity.unlockedLevels",
+              levelStars: "@entity.levelStars"
+            }]
+          ]
+        ]
+      },
+      {
+        event: "UNLOCK_LEVEL",
+        guard: ["not", ["array/includes", "@entity.unlockedLevels", "@payload.levelIndex"]],
+        effects: [
+          ["set", "@entity.unlockedLevels", ["array/append", "@entity.unlockedLevels", "@payload.levelIndex"]]
+        ]
+      },
+      {
+        from: "InLevel",
+        to: "Browsing",
+        event: "BACK_TO_SELECT",
+        effects: [
+          ["emit", "INIT"]
+        ]
+      }
+    ]
+  },
+  configSchema: {
+    required: [
+      { name: "levels", type: "array", description: "Level definitions" }
+    ],
+    optional: [
+      { name: "starsPerLevel", type: "number", description: "Max stars per level", default: 3 },
+      { name: "unlockNext", type: "boolean", description: "Auto-unlock next level on complete", default: true },
+      { name: "persistProgress", type: "boolean", description: "Save progress to storage", default: true }
+    ]
+  }
+};
+var GAME_UI_BEHAVIORS = [
+  GAME_FLOW_BEHAVIOR,
+  DIALOGUE_BEHAVIOR,
+  LEVEL_PROGRESS_BEHAVIOR
+];
+
+// behaviors/registry.ts
+var STANDARD_BEHAVIORS = [
+  ...UI_INTERACTION_BEHAVIORS,
+  ...DATA_MANAGEMENT_BEHAVIORS,
+  ...ASYNC_BEHAVIORS,
+  ...FEEDBACK_BEHAVIORS,
+  ...GAME_CORE_BEHAVIORS,
+  ...GAME_ENTITY_BEHAVIORS,
+  ...GAME_UI_BEHAVIORS
+];
+var BEHAVIOR_REGISTRY = STANDARD_BEHAVIORS.reduce(
+  (acc, behavior) => {
+    acc[behavior.name] = behavior;
+    return acc;
+  },
+  {}
+);
+var BEHAVIORS_BY_CATEGORY = {
+  "ui-interaction": UI_INTERACTION_BEHAVIORS,
+  "data-management": DATA_MANAGEMENT_BEHAVIORS,
+  "async": ASYNC_BEHAVIORS,
+  "feedback": FEEDBACK_BEHAVIORS,
+  "game-core": GAME_CORE_BEHAVIORS,
+  "game-entity": GAME_ENTITY_BEHAVIORS,
+  "game-ui": GAME_UI_BEHAVIORS
+};
+function getBehavior(name) {
+  return BEHAVIOR_REGISTRY[name];
+}
+function isKnownBehavior(name) {
+  return name in BEHAVIOR_REGISTRY;
+}
+function getBehaviorsByCategory(category) {
+  return BEHAVIORS_BY_CATEGORY[category] ?? [];
+}
+function getAllBehaviorNames() {
+  return Object.keys(BEHAVIOR_REGISTRY);
+}
+function getAllBehaviors() {
+  return STANDARD_BEHAVIORS;
+}
+function getAllBehaviorMetadata() {
+  return STANDARD_BEHAVIORS.map(getBehaviorMetadata);
+}
+function findBehaviorsForUseCase(useCase) {
+  const lowerUseCase = useCase.toLowerCase();
+  return STANDARD_BEHAVIORS.filter(
+    (behavior) => behavior.suggestedFor?.some(
+      (suggestion) => suggestion.toLowerCase().includes(lowerUseCase) || lowerUseCase.includes(suggestion.toLowerCase())
+    ) ?? false
+  );
+}
+function getBehaviorsForEvent(event) {
+  return STANDARD_BEHAVIORS.filter((behavior) => {
+    const events = behavior.stateMachine?.events || [];
+    return events.some((e) => (typeof e === "string" ? e : e.key) === event);
+  });
+}
+function getBehaviorsWithState(state) {
+  return STANDARD_BEHAVIORS.filter((behavior) => {
+    const states = behavior.stateMachine?.states || [];
+    return states.some((s) => (typeof s === "string" ? s : s.name) === state);
+  });
+}
+function validateBehaviorReference(name) {
+  if (!name.startsWith("std/")) {
+    return `Behavior name must start with 'std/': ${name}`;
+  }
+  if (!isKnownBehavior(name)) {
+    const suggestions = findSimilarBehaviors(name);
+    if (suggestions.length > 0) {
+      return `Unknown behavior '${name}'. Did you mean: ${suggestions.join(", ")}?`;
+    }
+    return `Unknown behavior: ${name}`;
+  }
+  return null;
+}
+function findSimilarBehaviors(name) {
+  const normalizedInput = name.toLowerCase().replace("std/", "");
+  return getAllBehaviorNames().filter((behaviorName) => {
+    const normalizedBehavior = behaviorName.toLowerCase().replace("std/", "");
+    return normalizedBehavior.includes(normalizedInput) || normalizedInput.includes(normalizedBehavior) || levenshteinDistance(normalizedInput, normalizedBehavior) <= 3;
+  });
+}
+function levenshteinDistance(a, b) {
+  if (a.length === 0) return b.length;
+  if (b.length === 0) return a.length;
+  const matrix = [];
+  for (let i = 0; i <= b.length; i++) {
+    matrix[i] = [i];
+  }
+  for (let j = 0; j <= a.length; j++) {
+    matrix[0][j] = j;
+  }
+  for (let i = 1; i <= b.length; i++) {
+    for (let j = 1; j <= a.length; j++) {
+      if (b.charAt(i - 1) === a.charAt(j - 1)) {
+        matrix[i][j] = matrix[i - 1][j - 1];
+      } else {
+        matrix[i][j] = Math.min(
+          matrix[i - 1][j - 1] + 1,
+          matrix[i][j - 1] + 1,
+          matrix[i - 1][j] + 1
+        );
+      }
+    }
+  }
+  return matrix[b.length][a.length];
+}
+function getBehaviorLibraryStats() {
+  const byCategory = {};
+  let totalStates = 0;
+  let totalEvents = 0;
+  let totalTransitions = 0;
+  let totalTicks = 0;
+  for (const behavior of STANDARD_BEHAVIORS) {
+    byCategory[behavior.category] = (byCategory[behavior.category] ?? 0) + 1;
+    const sm = behavior.stateMachine;
+    if (sm) {
+      totalStates += (sm.states || []).length;
+      totalEvents += (sm.events || []).length;
+      totalTransitions += (sm.transitions || []).length;
+    }
+    totalTicks += (behavior.ticks || []).length;
+  }
+  return {
+    totalBehaviors: STANDARD_BEHAVIORS.length,
+    byCategory,
+    totalStates,
+    totalEvents,
+    totalTransitions,
+    totalTicks
+  };
+}
+
+export { BEHAVIORS_BY_CATEGORY, BEHAVIOR_REGISTRY, STANDARD_BEHAVIORS, findBehaviorsForUseCase, getAllBehaviorMetadata, getAllBehaviorNames, getAllBehaviors, getBehavior, getBehaviorLibraryStats, getBehaviorsByCategory, getBehaviorsForEvent, getBehaviorsWithState, isKnownBehavior, validateBehaviorReference };
+//# sourceMappingURL=registry.js.map
+//# sourceMappingURL=registry.js.map