@almadar/core 1.0.0

package/dist/index.js

@@ -0,0 +1,1595 @@
+import { z } from 'zod';
+
+// src/types/orbital.ts
+var FieldTypeSchema = z.enum([
+  "string",
+  "number",
+  "boolean",
+  "date",
+  "timestamp",
+  "datetime",
+  "array",
+  "object",
+  "enum",
+  "relation"
+]);
+var RelationConfigSchema = z.object({
+  entity: z.string().min(1, "Target entity is required"),
+  field: z.string().optional(),
+  cardinality: z.enum(["one", "many"]).optional(),
+  onDelete: z.enum(["cascade", "nullify", "restrict"]).optional()
+});
+var FieldFormatSchema = z.enum([
+  "email",
+  "url",
+  "phone",
+  "date",
+  "datetime",
+  "uuid"
+]);
+var EntityFieldSchema = z.lazy(
+  () => z.object({
+    name: z.string().min(1, "Field name is required"),
+    type: FieldTypeSchema,
+    required: z.boolean().optional(),
+    default: z.unknown().optional(),
+    values: z.array(z.string()).optional(),
+    enum: z.array(z.string()).optional(),
+    format: FieldFormatSchema.optional(),
+    min: z.number().optional(),
+    max: z.number().optional(),
+    items: EntityFieldSchema.optional(),
+    relation: RelationConfigSchema.optional()
+  }).refine(
+    (field) => field.type !== "relation" || field.relation !== void 0,
+    { message: 'Relation config is required when type is "relation"', path: ["relation"] }
+  )
+);
+var FieldSchema = EntityFieldSchema;
+var ENTITY_ROLES = [
+  "player",
+  "enemy",
+  "npc",
+  "item",
+  "tile",
+  "projectile",
+  "effect",
+  "ui",
+  "decoration",
+  "vehicle"
+];
+var EntityRoleSchema = z.enum(ENTITY_ROLES);
+var VISUAL_STYLES = ["pixel", "vector", "hd", "1-bit", "isometric"];
+var VisualStyleSchema = z.enum(VISUAL_STYLES);
+var GAME_TYPES = [
+  "platformer",
+  "roguelike",
+  "top-down",
+  "puzzle",
+  "racing",
+  "card",
+  "board",
+  "shooter",
+  "rpg"
+];
+var GameTypeSchema = z.enum(GAME_TYPES);
+var AnimationDefSchema = z.object({
+  frames: z.union([z.array(z.number()), z.array(z.string())]),
+  fps: z.number().positive(),
+  loop: z.boolean()
+});
+var SemanticAssetRefSchema = z.object({
+  role: EntityRoleSchema,
+  category: z.string().min(1),
+  animations: z.array(z.string()).optional(),
+  style: VisualStyleSchema.optional(),
+  variant: z.string().optional()
+});
+var ResolvedAssetSchema = z.object({
+  basePath: z.string(),
+  path: z.string(),
+  tiles: z.array(z.number()).optional(),
+  tileSize: z.number().positive().optional(),
+  files: z.array(z.string()).optional(),
+  animations: z.record(AnimationDefSchema).optional()
+});
+var AssetMappingSchema = z.object({
+  path: z.string(),
+  tiles: z.array(z.number()).optional(),
+  tileSize: z.number().positive().optional(),
+  files: z.array(z.string()).optional(),
+  animations: z.record(AnimationDefSchema).optional()
+});
+var AssetMapSchema = z.object({
+  gameType: GameTypeSchema,
+  style: VisualStyleSchema,
+  basePath: z.string(),
+  mappings: z.record(AssetMappingSchema)
+});
+function createAssetKey(role, category) {
+  return `${role}:${category}`;
+}
+function parseAssetKey(key) {
+  const parts = key.split(":");
+  if (parts.length !== 2) return null;
+  return { role: parts[0], category: parts[1] };
+}
+function getDefaultAnimationsForRole(role) {
+  switch (role) {
+    case "player":
+      return ["idle", "run", "jump", "fall", "attack", "hurt", "die"];
+    case "enemy":
+      return ["idle", "walk", "attack", "hurt", "die"];
+    case "npc":
+      return ["idle", "walk", "talk"];
+    case "item":
+      return ["idle", "collected"];
+    case "tile":
+      return ["static"];
+    case "projectile":
+      return ["fly", "hit", "expire"];
+    case "effect":
+      return ["play"];
+    case "ui":
+      return ["normal", "hover", "pressed", "disabled"];
+    case "decoration":
+      return ["idle"];
+    case "vehicle":
+      return ["idle", "move", "brake"];
+    default:
+      return ["idle"];
+  }
+}
+function validateAssetAnimations(assetRef, requiredAnimations) {
+  const provided = assetRef.animations || [];
+  const missing = requiredAnimations.filter((anim) => !provided.includes(anim));
+  return { valid: missing.length === 0, missing };
+}
+
+// src/types/entity.ts
+var EntityPersistenceSchema = z.enum([
+  "persistent",
+  "runtime",
+  "singleton",
+  "instance"
+]);
+var OrbitalEntitySchema = z.object({
+  name: z.string().min(1, "Entity name is required"),
+  persistence: EntityPersistenceSchema.default("persistent"),
+  collection: z.string().optional(),
+  fields: z.array(EntityFieldSchema).min(1, "At least one field is required"),
+  timestamps: z.boolean().optional(),
+  softDelete: z.boolean().optional(),
+  description: z.string().optional(),
+  visual_prompt: z.string().optional(),
+  assetRef: SemanticAssetRefSchema.optional()
+});
+var EntitySchema = OrbitalEntitySchema;
+function deriveCollection(entity) {
+  if (entity.persistence !== "persistent") {
+    return void 0;
+  }
+  return entity.name.toLowerCase() + "s";
+}
+function isRuntimeEntity(entity) {
+  return entity.persistence === "runtime";
+}
+function isSingletonEntity(entity) {
+  return entity.persistence === "singleton";
+}
+var ViewTypeSchema = z.enum([
+  "list",
+  "detail",
+  "create",
+  "edit",
+  "dashboard",
+  "custom"
+]);
+var PageTraitRefSchema = z.object({
+  ref: z.string().min(1, "Trait ref is required"),
+  linkedEntity: z.string().optional(),
+  config: z.record(z.unknown()).optional()
+});
+var OrbitalPageStrictSchema = z.object({
+  name: z.string().min(1, "Page name is required"),
+  path: z.string().min(1, "Page path is required").startsWith("/", "Path must start with /"),
+  primaryEntity: z.string().min(1, "Primary entity is required"),
+  traits: z.array(PageTraitRefSchema).min(1, "Page must have at least one trait"),
+  title: z.string().optional()
+}).strict();
+var OrbitalPageSchema = z.object({
+  name: z.string().min(1, "Page name is required"),
+  path: z.string().min(1, "Page path is required").startsWith("/", "Path must start with /"),
+  viewType: ViewTypeSchema.optional(),
+  title: z.string().optional(),
+  primaryEntity: z.string().optional(),
+  traits: z.array(PageTraitRefSchema).optional(),
+  isInitial: z.boolean().optional()
+}).strict();
+var PageSchema = OrbitalPageSchema;
+var UI_SLOTS = [
+  "main",
+  "sidebar",
+  "modal",
+  "drawer",
+  "overlay",
+  "center",
+  "toast",
+  "hud-top",
+  "hud-bottom",
+  "floating",
+  "system"
+  // For invisible system components (InputListener, CollisionDetector)
+];
+var UISlotSchema = z.enum(UI_SLOTS);
+var EffectSchema = z.array(z.unknown()).min(1).refine(
+  (arr) => typeof arr[0] === "string",
+  { message: "Effect must be an S-expression with a string operator as first element" }
+);
+function isEffect(value) {
+  return Array.isArray(value) && value.length > 0 && typeof value[0] === "string";
+}
+var isSExprEffect = isEffect;
+function set(binding, value) {
+  return ["set", binding, value];
+}
+function emit(event, payload) {
+  return payload ? ["emit", event, payload] : ["emit", event];
+}
+function navigate(path, params) {
+  return params ? ["navigate", path, params] : ["navigate", path];
+}
+function renderUI(target, pattern, props) {
+  const patternObj = pattern ? { ...pattern } : null;
+  return props ? ["render-ui", target, patternObj, props] : ["render-ui", target, patternObj];
+}
+function persist(action, entity, data) {
+  return data ? ["persist", action, entity, data] : ["persist", action, entity];
+}
+function callService(service, config) {
+  return ["call-service", service, config];
+}
+function spawn(entity, initialState) {
+  return initialState ? ["spawn", entity, initialState] : ["spawn", entity];
+}
+function despawn(entityId) {
+  return ["despawn", entityId];
+}
+function doEffects(...effects) {
+  return ["do", ...effects];
+}
+function notify(channel, message, recipient) {
+  return recipient ? ["notify", channel, message, recipient] : ["notify", channel, message];
+}
+var SExprAtomSchema = z.union([
+  z.string(),
+  z.number(),
+  z.boolean(),
+  z.null(),
+  z.record(z.unknown())
+  // Objects for payload data
+]);
+var SExprSchema = z.lazy(
+  () => z.union([
+    SExprAtomSchema,
+    z.array(z.lazy(() => SExprSchema)).min(1).refine(
+      (arr) => typeof arr[0] === "string",
+      { message: "S-expression array must have a string operator as first element" }
+    )
+  ])
+);
+var ExpressionSchema = SExprSchema;
+function isSExpr(value) {
+  return Array.isArray(value) && value.length > 0 && typeof value[0] === "string";
+}
+function isSExprAtom(value) {
+  if (value === null) return true;
+  if (Array.isArray(value)) return false;
+  const type = typeof value;
+  return type === "string" || type === "number" || type === "boolean" || type === "object";
+}
+function isBinding(value) {
+  return typeof value === "string" && value.startsWith("@");
+}
+function isSExprCall(value) {
+  return isSExpr(value);
+}
+var CORE_BINDINGS = ["entity", "payload", "state", "now", "config", "computed", "trait"];
+function parseBinding(binding) {
+  if (!binding.startsWith("@")) {
+    return null;
+  }
+  const withoutPrefix = binding.slice(1);
+  const parts = withoutPrefix.split(".");
+  if (parts.length === 0 || parts[0] === "") {
+    return null;
+  }
+  const root = parts[0];
+  const path = parts.slice(1);
+  const isCore = CORE_BINDINGS.includes(root);
+  return {
+    type: isCore ? "core" : "entity",
+    root,
+    path,
+    original: binding
+  };
+}
+function isValidBinding(binding) {
+  const parsed = parseBinding(binding);
+  if (!parsed) return false;
+  if (parsed.type === "core") {
+    if (parsed.root === "state" || parsed.root === "now") {
+      return parsed.path.length === 0;
+    }
+    return true;
+  }
+  return parsed.path.length > 0;
+}
+function getOperator(expr) {
+  if (!isSExpr(expr)) return null;
+  return expr[0];
+}
+function getArgs(expr) {
+  if (!isSExpr(expr)) return [];
+  return expr.slice(1);
+}
+function sexpr(operator, ...args) {
+  return [operator, ...args];
+}
+function walkSExpr(expr, visitor, parent = null, index = 0) {
+  visitor(expr, parent, index);
+  if (isSExpr(expr)) {
+    for (let i = 0; i < expr.length; i++) {
+      walkSExpr(expr[i], visitor, expr, i);
+    }
+  }
+}
+function collectBindings(expr) {
+  const bindings = [];
+  walkSExpr(expr, (node) => {
+    if (isBinding(node)) {
+      bindings.push(node);
+    }
+  });
+  return bindings;
+}
+
+// src/types/state-machine.ts
+var StateSchema = z.object({
+  name: z.string().min(1, "State name is required"),
+  isInitial: z.boolean().optional(),
+  isTerminal: z.boolean().optional(),
+  isFinal: z.boolean().optional(),
+  description: z.string().optional(),
+  onEntry: z.array(z.string()).optional(),
+  onExit: z.array(z.string()).optional()
+});
+var PayloadFieldSchema = z.object({
+  name: z.string().min(1),
+  type: z.enum(["string", "number", "boolean", "object", "array"]),
+  required: z.boolean().optional()
+});
+var EventSchema = z.object({
+  key: z.string().min(1, "Event key is required"),
+  name: z.string().min(1, "Event name is required"),
+  description: z.string().optional(),
+  payloadSchema: z.array(PayloadFieldSchema).optional(),
+  classification: z.enum(["domain", "system"]).optional(),
+  semanticRole: z.string().optional()
+});
+var GuardSchema = z.object({
+  name: z.string().min(1, "Guard name is required"),
+  expression: ExpressionSchema,
+  description: z.string().optional()
+});
+var TransitionSchema = z.object({
+  from: z.string().min(1, "Transition source state is required"),
+  to: z.string().min(1, "Transition target state is required"),
+  event: z.string().min(1, "Transition event is required"),
+  guard: ExpressionSchema.nullish(),
+  effects: z.array(EffectSchema).optional(),
+  description: z.string().nullish()
+});
+var StateMachineSchema = z.object({
+  states: z.array(StateSchema).min(1, "At least one state is required"),
+  events: z.array(EventSchema),
+  transitions: z.array(TransitionSchema),
+  guards: z.array(GuardSchema).optional()
+});
+
+// src/types/trait.ts
+var TraitCategorySchema = z.enum([
+  "lifecycle",
+  "temporal",
+  "validation",
+  "notification",
+  "integration",
+  "interaction",
+  "game-core",
+  "game-character",
+  "game-ai",
+  "game-combat",
+  "game-items",
+  "game-cards",
+  "game-board",
+  "game-puzzle"
+]);
+var TraitEntityFieldSchema = z.object({
+  name: z.string().min(1),
+  type: z.enum([
+    "string",
+    "number",
+    "boolean",
+    "date",
+    "array",
+    "object",
+    "timestamp",
+    "datetime",
+    "enum"
+  ]),
+  required: z.boolean().optional(),
+  default: z.unknown().optional(),
+  values: z.array(z.string()).optional()
+});
+var TraitDataEntitySchema = z.object({
+  name: z.string().min(1),
+  collection: z.string().optional(),
+  fields: z.array(TraitEntityFieldSchema).min(1),
+  timestamps: z.boolean().optional(),
+  description: z.string().optional(),
+  runtime: z.boolean().optional(),
+  singleton: z.boolean().optional(),
+  pages: z.array(z.string()).optional()
+});
+var TraitTickSchema = z.object({
+  name: z.string().min(1),
+  description: z.string().optional(),
+  priority: z.number().optional(),
+  interval: z.union([z.literal("frame"), z.number().positive()]),
+  appliesTo: z.array(z.string()).optional(),
+  pages: z.array(z.string()).optional(),
+  guard: ExpressionSchema.optional(),
+  effects: z.array(EffectSchema).min(1),
+  emits: z.array(z.string()).optional()
+});
+var EventScopeSchema = z.enum(["internal", "external"]);
+var EventPayloadFieldSchema = z.object({
+  name: z.string().min(1),
+  type: z.enum(["string", "number", "boolean", "object", "array", "entity"]),
+  required: z.boolean().optional(),
+  description: z.string().optional(),
+  entityType: z.string().optional()
+});
+var TraitEventContractSchema = z.object({
+  event: z.string().min(1).regex(
+    /^[A-Z][A-Z0-9_]*$/,
+    "Event name must be UPPER_SNAKE_CASE"
+  ),
+  description: z.string().optional(),
+  payload: z.array(EventPayloadFieldSchema).optional(),
+  scope: EventScopeSchema.optional()
+});
+var TraitEventListenerSchema = z.object({
+  event: z.string().min(1),
+  triggers: z.string().min(1),
+  guard: ExpressionSchema.optional(),
+  scope: EventScopeSchema.optional(),
+  payloadMapping: z.record(z.string()).optional()
+});
+var RequiredFieldSchema = z.object({
+  name: z.string().min(1),
+  type: z.enum(["string", "number", "boolean", "date", "array", "object", "timestamp", "datetime", "enum"]),
+  description: z.string().optional()
+});
+var TraitReferenceSchema = z.object({
+  ref: z.string().min(1),
+  linkedEntity: z.string().optional(),
+  config: z.record(z.record(z.unknown())).optional(),
+  appliesTo: z.array(z.string()).optional()
+});
+var TraitSchema = z.object({
+  name: z.string().min(1),
+  description: z.string().optional(),
+  description_visual_prompt: z.string().optional(),
+  category: TraitCategorySchema.optional(),
+  requiredFields: z.array(RequiredFieldSchema).optional(),
+  dataEntities: z.array(TraitDataEntitySchema).optional(),
+  stateMachine: StateMachineSchema.optional(),
+  initialEffects: z.array(EffectSchema).optional(),
+  ticks: z.array(TraitTickSchema).optional(),
+  emits: z.array(TraitEventContractSchema).optional(),
+  listens: z.array(TraitEventListenerSchema).optional(),
+  ui: z.record(z.unknown()).optional()
+});
+var TraitRefSchema = z.union([
+  z.string().min(1),
+  z.object({
+    ref: z.string().min(1),
+    config: z.record(z.unknown()).optional(),
+    linkedEntity: z.string().optional()
+  }),
+  TraitSchema
+  // Allow inline trait definitions
+]);
+function isInlineTrait(traitRef) {
+  return typeof traitRef === "object" && "name" in traitRef && !("ref" in traitRef);
+}
+function getTraitName(traitRef) {
+  if (typeof traitRef === "string") {
+    return traitRef;
+  }
+  if (isInlineTrait(traitRef)) {
+    return traitRef.name;
+  }
+  return traitRef.ref;
+}
+function getTraitConfig(traitRef) {
+  if (typeof traitRef === "string") {
+    return void 0;
+  }
+  if (isInlineTrait(traitRef)) {
+    return void 0;
+  }
+  return traitRef.config;
+}
+function normalizeTraitRef(traitRef) {
+  if (typeof traitRef === "string") {
+    return { ref: traitRef };
+  }
+  if (isInlineTrait(traitRef)) {
+    return { ref: traitRef.name };
+  }
+  return traitRef;
+}
+var OrbitalTraitRefSchema = TraitRefSchema;
+var DomainCategorySchema = z.enum([
+  "healthcare",
+  "education",
+  "finance",
+  "ecommerce",
+  "real-estate",
+  "logistics",
+  "hospitality",
+  "hr-management",
+  "project-management",
+  "social",
+  "content-management",
+  "iot",
+  "analytics",
+  "game",
+  "custom"
+]);
+var GameSubCategorySchema = z.enum([
+  "platformer",
+  "shooter",
+  "puzzle",
+  "rpg",
+  "board",
+  "racing",
+  "fighting",
+  "tower-defense",
+  "endless-runner",
+  "simulation",
+  "arcade",
+  "adventure"
+]);
+var NodeClassificationSchema = z.enum(["domain", "system"]);
+var StateSemanticRoleSchema = z.enum([
+  "pending",
+  "active",
+  "completed",
+  "cancelled",
+  "error",
+  "suspended",
+  "blocked",
+  "domain_workflow",
+  "domain_status",
+  "system_loading",
+  "system_error",
+  "system_idle",
+  "system_editing",
+  "system_confirming"
+]);
+var EventSemanticRoleSchema = z.enum([
+  "domain_action",
+  "domain_trigger",
+  "system_crud",
+  "system_navigation",
+  "system_form",
+  "system_ui"
+]);
+var EntitySemanticRoleSchema = z.enum([
+  "domain_core",
+  "domain_supporting",
+  "domain_reference",
+  "system_user",
+  "system_config",
+  "system_audit"
+]);
+var DomainVocabularySchema = z.record(z.string(), z.string()).optional();
+var UserPersonaSchema = z.object({
+  name: z.string().min(1),
+  role: z.string().optional(),
+  device: z.enum(["mobile", "tablet", "desktop"]).optional()
+});
+var DomainContextSchema = z.object({
+  request: z.string().min(1, "Original request is required"),
+  requestFragment: z.string().optional(),
+  category: z.enum([
+    "game",
+    "business",
+    "dashboard",
+    "form",
+    "content",
+    "social"
+  ]),
+  subDomain: z.string().optional(),
+  personas: z.array(UserPersonaSchema).optional(),
+  vocabulary: DomainVocabularySchema.optional()
+});
+var UXHintsSchema = z.object({
+  flowPattern: z.string().optional(),
+  listPattern: z.string().optional(),
+  formPattern: z.string().optional(),
+  detailPattern: z.string().optional(),
+  relatedLinks: z.array(z.lazy(() => RelatedLinkSchema)).optional()
+});
+var RelatedLinkSchema = z.object({
+  relation: z.string().min(1),
+  label: z.string().min(1),
+  targetView: z.enum(["list", "detail"]).optional()
+});
+var SuggestedGuardSchema = z.object({
+  id: z.string().min(1),
+  description: z.string().min(1),
+  appliesTo: z.array(z.string().min(1))
+});
+var DesignPreferencesSchema = z.object({
+  style: z.enum(["minimal", "modern", "playful", "data-driven", "immersive"]).optional(),
+  primaryColor: z.string().regex(/^#[0-9A-Fa-f]{6}$/, "Must be valid hex color").optional(),
+  device: z.enum(["mobile", "tablet", "desktop", "all"]).optional(),
+  darkMode: z.boolean().optional(),
+  uxHints: UXHintsSchema.optional()
+});
+var ThemeTokensSchema = z.object({
+  colors: z.record(z.string(), z.string()).optional(),
+  radii: z.record(z.string(), z.string()).optional(),
+  spacing: z.record(z.string(), z.string()).optional(),
+  typography: z.record(z.string(), z.string()).optional(),
+  shadows: z.record(z.string(), z.string()).optional()
+});
+var ThemeVariantSchema = z.object({
+  colors: z.record(z.string(), z.string()).optional(),
+  radii: z.record(z.string(), z.string()).optional(),
+  spacing: z.record(z.string(), z.string()).optional(),
+  typography: z.record(z.string(), z.string()).optional(),
+  shadows: z.record(z.string(), z.string()).optional()
+});
+var ThemeDefinitionSchema = z.object({
+  name: z.string().min(1, "Theme name is required"),
+  tokens: ThemeTokensSchema,
+  variants: z.record(z.string(), ThemeVariantSchema).optional()
+});
+function isThemeReference(theme) {
+  return typeof theme === "string";
+}
+var ThemeRefStringSchema = z.string().regex(
+  /^[A-Z][a-zA-Z0-9]*\.theme$/,
+  'Theme reference must be in format "Alias.theme" (e.g., "Ocean.theme")'
+);
+var ThemeRefSchema = z.union([
+  ThemeDefinitionSchema,
+  ThemeRefStringSchema
+]);
+var DesignTokensSchema = z.record(z.string(), z.record(z.string(), z.string())).optional();
+var ALLOWED_CUSTOM_COMPONENTS = [
+  "div",
+  "span",
+  "button",
+  "a",
+  "p",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "header",
+  "footer",
+  "section",
+  "article",
+  "nav",
+  "main",
+  "aside",
+  "ul",
+  "ol",
+  "li",
+  "img",
+  "label",
+  "input",
+  "form"
+];
+var CustomPatternDefinitionSchema = z.object({
+  type: z.literal("custom"),
+  component: z.enum(ALLOWED_CUSTOM_COMPONENTS),
+  className: z.string(),
+  slots: z.array(z.string()).optional(),
+  props: z.array(z.string()).optional()
+});
+var CustomPatternMapSchema = z.record(z.string(), CustomPatternDefinitionSchema).optional();
+var SERVICE_TYPES = ["rest", "socket", "mcp"];
+var ServiceTypeSchema = z.enum(SERVICE_TYPES);
+var RestAuthConfigSchema = z.object({
+  type: z.enum(["api-key", "bearer", "basic", "oauth2"]),
+  keyName: z.string().optional(),
+  location: z.enum(["query", "header"]).optional(),
+  secretEnv: z.string().optional()
+});
+var RestServiceDefSchema = z.object({
+  name: z.string().min(1, "Service name is required"),
+  type: z.literal("rest"),
+  description: z.string().optional(),
+  baseUrl: z.string().url("Base URL must be a valid URL"),
+  headers: z.record(z.string()).optional(),
+  auth: RestAuthConfigSchema.optional(),
+  timeout: z.number().positive().optional()
+});
+var SocketEventsSchema = z.object({
+  inbound: z.array(z.string()),
+  outbound: z.array(z.string())
+});
+var SocketServiceDefSchema = z.object({
+  name: z.string().min(1, "Service name is required"),
+  type: z.literal("socket"),
+  description: z.string().optional(),
+  url: z.string().url("WebSocket URL must be valid"),
+  events: SocketEventsSchema,
+  reconnect: z.object({
+    enabled: z.boolean(),
+    maxAttempts: z.number().positive().optional(),
+    delayMs: z.number().positive().optional()
+  }).optional()
+});
+var McpServiceDefSchema = z.object({
+  name: z.string().min(1, "Service name is required"),
+  type: z.literal("mcp"),
+  description: z.string().optional(),
+  serverPath: z.string().min(1, "Server path is required"),
+  capabilities: z.array(z.string()).min(1, "At least one capability is required"),
+  env: z.record(z.string()).optional()
+});
+var ServiceDefinitionSchema = z.discriminatedUnion("type", [
+  RestServiceDefSchema,
+  SocketServiceDefSchema,
+  McpServiceDefSchema
+]);
+function isServiceReference(service) {
+  return typeof service === "string";
+}
+var ServiceRefStringSchema = z.string().regex(
+  /^[A-Z][a-zA-Z0-9]*\.services\.[a-zA-Z][a-zA-Z0-9]*$/,
+  'Service reference must be in format "Alias.services.ServiceName" (e.g., "Weather.services.openweather")'
+);
+var ServiceRefSchema = z.union([
+  ServiceDefinitionSchema,
+  ServiceRefStringSchema
+]);
+function parseServiceRef(ref) {
+  const match = ref.match(
+    /^([A-Z][a-zA-Z0-9]*)\.services\.([a-zA-Z][a-zA-Z0-9]*)$/
+  );
+  if (!match) return null;
+  return { alias: match[1], serviceName: match[2] };
+}
+function isRestService(service) {
+  return service.type === "rest";
+}
+function isSocketService(service) {
+  return service.type === "socket";
+}
+function isMcpService(service) {
+  return service.type === "mcp";
+}
+function getServiceNames(services) {
+  return services.map((s) => s.name);
+}
+function findService(services, name) {
+  return services.find((s) => s.name.toLowerCase() === name.toLowerCase());
+}
+function hasService(services, name) {
+  return services.some((s) => s.name.toLowerCase() === name.toLowerCase());
+}
+
+// src/types/orbital.ts
+var UseDeclarationSchema = z.object({
+  from: z.string().min(1, "Import source is required"),
+  as: z.string().min(1, "Alias is required").regex(
+    /^[A-Z][a-zA-Z0-9]*$/,
+    'Alias must be PascalCase (e.g., "Health", "GameCore")'
+  )
+});
+function isEntityReference(entity) {
+  return typeof entity === "string";
+}
+var EntityRefStringSchema = z.string().regex(
+  /^[A-Z][a-zA-Z0-9]*\.entity$/,
+  'Entity reference must be in format "Alias.entity" (e.g., "Goblin.entity")'
+);
+var EntityRefSchema = z.union([EntitySchema, EntityRefStringSchema]);
+function isPageReferenceString(page) {
+  return typeof page === "string";
+}
+function isPageReferenceObject(page) {
+  return typeof page === "object" && "ref" in page && !("name" in page);
+}
+function isPageReference(page) {
+  return isPageReferenceString(page) || isPageReferenceObject(page);
+}
+var PageRefStringSchema = z.string().regex(
+  /^[A-Z][a-zA-Z0-9]*\.pages\.[A-Z][a-zA-Z0-9]*$/,
+  'Page reference must be in format "Alias.pages.PageName" (e.g., "User.pages.Profile")'
+);
+var PageRefObjectSchema = z.object({
+  ref: PageRefStringSchema,
+  path: z.string().startsWith("/").optional()
+});
+var PageRefSchema = z.union([
+  PageSchema,
+  PageRefStringSchema,
+  PageRefObjectSchema
+]);
+z.string().regex(
+  /^([A-Z][a-zA-Z0-9]*\.traits\.)?[A-Z][a-zA-Z0-9]*$/,
+  'Trait reference must be "TraitName" or "Alias.traits.TraitName"'
+);
+function isImportedTraitRef(ref) {
+  return /^[A-Z][a-zA-Z0-9]*\.traits\.[A-Z][a-zA-Z0-9]*$/.test(ref);
+}
+function parseImportedTraitRef(ref) {
+  const match = ref.match(/^([A-Z][a-zA-Z0-9]*)\.traits\.([A-Z][a-zA-Z0-9]*)$/);
+  if (!match) return null;
+  return { alias: match[1], traitName: match[2] };
+}
+function parseEntityRef(ref) {
+  const match = ref.match(/^([A-Z][a-zA-Z0-9]*)\.entity$/);
+  if (!match) return null;
+  return { alias: match[1] };
+}
+function parsePageRef(ref) {
+  const match = ref.match(/^([A-Z][a-zA-Z0-9]*)\.pages\.([A-Z][a-zA-Z0-9]*)$/);
+  if (!match) return null;
+  return { alias: match[1], pageName: match[2] };
+}
+var EventListenerSchema = z.object({
+  event: z.string().min(1),
+  triggers: z.string().min(1),
+  guard: z.string().optional()
+});
+var EventSourceSchema = z.object({
+  trait: z.string().min(1),
+  transition: z.string().optional(),
+  tick: z.string().optional()
+});
+var ComputedEventContractSchema = z.object({
+  event: z.string().min(1),
+  originalEvent: z.string().min(1),
+  source: EventSourceSchema,
+  description: z.string().optional(),
+  payload: z.array(EventPayloadFieldSchema).optional()
+});
+var ComputedEventListenerSchema = z.object({
+  event: z.string().min(1),
+  source: EventSourceSchema,
+  triggers: z.string().min(1),
+  guard: ExpressionSchema.optional(),
+  payloadMapping: z.record(z.string()).optional()
+});
+var OrbitalDefinitionSchema = z.object({
+  name: z.string().min(1, "Orbital name is required"),
+  description: z.string().optional(),
+  visual_prompt: z.string().optional(),
+  // Import system
+  uses: z.array(UseDeclarationSchema).optional(),
+  // Theme & Services
+  theme: ThemeRefSchema.optional(),
+  services: z.array(ServiceRefSchema).optional(),
+  // Components (inline or reference)
+  entity: EntityRefSchema,
+  traits: z.array(TraitRefSchema),
+  pages: z.array(PageRefSchema),
+  // Event interface (trait-centric model) - computed by resolver
+  emits: z.array(ComputedEventContractSchema).optional(),
+  listens: z.array(ComputedEventListenerSchema).optional(),
+  // Filter for exposed events (trait-centric model)
+  exposes: z.array(z.string()).optional(),
+  // Context fields - persisted throughout orbital lifecycle
+  domainContext: DomainContextSchema.optional(),
+  design: DesignPreferencesSchema.optional(),
+  suggestedGuards: z.array(SuggestedGuardSchema).optional()
+});
+var OrbitalSchema = OrbitalDefinitionSchema;
+function isOrbitalDefinition(orbital) {
+  return "entity" in orbital;
+}
+var OrbitalUnitSchema = OrbitalSchema;
+var OrbitalConfigSchema = z.object({
+  theme: z.object({
+    primary: z.string().optional(),
+    secondary: z.string().optional(),
+    mode: z.enum(["light", "dark", "system"]).optional()
+  }).optional(),
+  features: z.record(z.boolean()).optional(),
+  api: z.object({
+    baseUrl: z.string().optional(),
+    timeout: z.number().optional()
+  }).optional()
+});
+var OrbitalSchemaSchema = z.object({
+  name: z.string().min(1, "Schema name is required"),
+  description: z.string().optional(),
+  version: z.string().optional(),
+  domainContext: DomainContextSchema.optional(),
+  design: DesignPreferencesSchema.optional(),
+  designTokens: DesignTokensSchema,
+  customPatterns: CustomPatternMapSchema,
+  orbitals: z.array(OrbitalSchema).min(1, "At least one orbital is required"),
+  services: z.array(ServiceDefinitionSchema).optional(),
+  config: OrbitalConfigSchema.optional()
+});
+function parseOrbitalSchema(data) {
+  return OrbitalSchemaSchema.parse(data);
+}
+function safeParseOrbitalSchema(data) {
+  return OrbitalSchemaSchema.safeParse(data);
+}
+
+// src/types/operators.ts
+var OPERATOR_CATEGORIES = [
+  "arithmetic",
+  "comparison",
+  "logic",
+  "control",
+  "effect",
+  "collection",
+  // Standard library categories
+  "std-math",
+  "std-str",
+  "std-array",
+  "std-object",
+  "std-validate",
+  "std-time",
+  "std-format",
+  "std-async",
+  "std-nn",
+  "std-tensor",
+  "std-train"
+];
+var OPERATORS = {
+  // ============================================================================
+  // Arithmetic Operators
+  // ============================================================================
+  "+": {
+    category: "arithmetic",
+    minArity: 2,
+    maxArity: null,
+    description: "Add numbers",
+    hasSideEffects: false,
+    returnType: "number"
+  },
+  "-": {
+    category: "arithmetic",
+    minArity: 1,
+    maxArity: 2,
+    description: "Subtract numbers or negate",
+    hasSideEffects: false,
+    returnType: "number"
+  },
+  "*": {
+    category: "arithmetic",
+    minArity: 2,
+    maxArity: null,
+    description: "Multiply numbers",
+    hasSideEffects: false,
+    returnType: "number"
+  },
+  "/": {
+    category: "arithmetic",
+    minArity: 2,
+    maxArity: 2,
+    description: "Divide numbers",
+    hasSideEffects: false,
+    returnType: "number"
+  },
+  "%": {
+    category: "arithmetic",
+    minArity: 2,
+    maxArity: 2,
+    description: "Modulo (remainder)",
+    hasSideEffects: false,
+    returnType: "number"
+  },
+  abs: {
+    category: "arithmetic",
+    minArity: 1,
+    maxArity: 1,
+    description: "Absolute value",
+    hasSideEffects: false,
+    returnType: "number"
+  },
+  min: {
+    category: "arithmetic",
+    minArity: 2,
+    maxArity: null,
+    description: "Minimum of values",
+    hasSideEffects: false,
+    returnType: "number"
+  },
+  max: {
+    category: "arithmetic",
+    minArity: 2,
+    maxArity: null,
+    description: "Maximum of values",
+    hasSideEffects: false,
+    returnType: "number"
+  },
+  floor: {
+    category: "arithmetic",
+    minArity: 1,
+    maxArity: 1,
+    description: "Round down to integer",
+    hasSideEffects: false,
+    returnType: "number"
+  },
+  ceil: {
+    category: "arithmetic",
+    minArity: 1,
+    maxArity: 1,
+    description: "Round up to integer",
+    hasSideEffects: false,
+    returnType: "number"
+  },
+  round: {
+    category: "arithmetic",
+    minArity: 1,
+    maxArity: 1,
+    description: "Round to nearest integer",
+    hasSideEffects: false,
+    returnType: "number"
+  },
+  clamp: {
+    category: "arithmetic",
+    minArity: 3,
+    maxArity: 3,
+    description: "Clamp value between min and max",
+    hasSideEffects: false,
+    returnType: "number"
+  },
+  // ============================================================================
+  // Comparison Operators
+  // ============================================================================
+  "=": {
+    category: "comparison",
+    minArity: 2,
+    maxArity: 2,
+    description: "Equal to",
+    hasSideEffects: false,
+    returnType: "boolean"
+  },
+  "!=": {
+    category: "comparison",
+    minArity: 2,
+    maxArity: 2,
+    description: "Not equal to",
+    hasSideEffects: false,
+    returnType: "boolean"
+  },
+  "<": {
+    category: "comparison",
+    minArity: 2,
+    maxArity: 2,
+    description: "Less than",
+    hasSideEffects: false,
+    returnType: "boolean"
+  },
+  ">": {
+    category: "comparison",
+    minArity: 2,
+    maxArity: 2,
+    description: "Greater than",
+    hasSideEffects: false,
+    returnType: "boolean"
+  },
+  "<=": {
+    category: "comparison",
+    minArity: 2,
+    maxArity: 2,
+    description: "Less than or equal to",
+    hasSideEffects: false,
+    returnType: "boolean"
+  },
+  ">=": {
+    category: "comparison",
+    minArity: 2,
+    maxArity: 2,
+    description: "Greater than or equal to",
+    hasSideEffects: false,
+    returnType: "boolean"
+  },
+  // ============================================================================
+  // Logic Operators
+  // ============================================================================
+  and: {
+    category: "logic",
+    minArity: 2,
+    maxArity: null,
+    description: "Logical AND (short-circuit)",
+    hasSideEffects: false,
+    returnType: "boolean"
+  },
+  or: {
+    category: "logic",
+    minArity: 2,
+    maxArity: null,
+    description: "Logical OR (short-circuit)",
+    hasSideEffects: false,
+    returnType: "boolean"
+  },
+  not: {
+    category: "logic",
+    minArity: 1,
+    maxArity: 1,
+    description: "Logical NOT",
+    hasSideEffects: false,
+    returnType: "boolean"
+  },
+  if: {
+    category: "logic",
+    minArity: 3,
+    maxArity: 3,
+    description: "Conditional expression (if condition then else)",
+    hasSideEffects: false,
+    returnType: "any"
+  },
+  // ============================================================================
+  // Control Operators
+  // ============================================================================
+  let: {
+    category: "control",
+    minArity: 2,
+    maxArity: 2,
+    description: "Bind local variables: [let, [[name, value], ...], body]",
+    hasSideEffects: false,
+    returnType: "any"
+  },
+  do: {
+    category: "control",
+    minArity: 1,
+    maxArity: null,
+    description: "Execute expressions in sequence, return last",
+    hasSideEffects: true,
+    returnType: "any"
+  },
+  when: {
+    category: "control",
+    minArity: 2,
+    maxArity: 2,
+    description: "Execute effect only when condition is true",
+    hasSideEffects: true,
+    returnType: "void"
+  },
+  fn: {
+    category: "control",
+    minArity: 2,
+    maxArity: 2,
+    description: "Lambda expression: [fn, varName, body] or [fn, [vars], body]",
+    hasSideEffects: false,
+    returnType: "any"
+  },
+  // ============================================================================
+  // Effect Operators
+  // ============================================================================
+  set: {
+    category: "effect",
+    minArity: 2,
+    maxArity: 2,
+    description: "Set a binding to a value",
+    hasSideEffects: true,
+    returnType: "void"
+  },
+  emit: {
+    category: "effect",
+    minArity: 1,
+    maxArity: 2,
+    description: "Emit an event with optional payload",
+    hasSideEffects: true,
+    returnType: "void"
+  },
+  persist: {
+    category: "effect",
+    minArity: 2,
+    maxArity: 3,
+    description: "Persist data (create/update/delete)",
+    hasSideEffects: true,
+    returnType: "void"
+  },
+  navigate: {
+    category: "effect",
+    minArity: 1,
+    maxArity: 2,
+    description: "Navigate to a route",
+    hasSideEffects: true,
+    returnType: "void"
+  },
+  notify: {
+    category: "effect",
+    minArity: 1,
+    maxArity: 2,
+    description: "Show a notification",
+    hasSideEffects: true,
+    returnType: "void"
+  },
+  spawn: {
+    category: "effect",
+    minArity: 1,
+    maxArity: 2,
+    description: "Spawn a new entity instance",
+    hasSideEffects: true,
+    returnType: "void"
+  },
+  despawn: {
+    category: "effect",
+    minArity: 0,
+    maxArity: 1,
+    description: "Despawn an entity instance",
+    hasSideEffects: true,
+    returnType: "void"
+  },
+  "call-service": {
+    category: "effect",
+    minArity: 2,
+    maxArity: 3,
+    description: "Call an external service",
+    hasSideEffects: true,
+    returnType: "void"
+  },
+  "render-ui": {
+    category: "effect",
+    minArity: 2,
+    maxArity: 3,
+    description: "Render UI to a slot",
+    hasSideEffects: true,
+    returnType: "void"
+  },
+  // ============================================================================
+  // Collection Operators
+  // ============================================================================
+  map: {
+    category: "collection",
+    minArity: 2,
+    maxArity: 2,
+    description: "Transform each element in collection",
+    hasSideEffects: false,
+    returnType: "array"
+  },
+  filter: {
+    category: "collection",
+    minArity: 2,
+    maxArity: 2,
+    description: "Filter collection by predicate",
+    hasSideEffects: false,
+    returnType: "array"
+  },
+  find: {
+    category: "collection",
+    minArity: 2,
+    maxArity: 2,
+    description: "Find first element matching predicate",
+    hasSideEffects: false,
+    returnType: "any"
+  },
+  count: {
+    category: "collection",
+    minArity: 1,
+    maxArity: 1,
+    description: "Count elements in collection",
+    hasSideEffects: false,
+    returnType: "number"
+  },
+  sum: {
+    category: "collection",
+    minArity: 1,
+    maxArity: 2,
+    description: "Sum values in collection",
+    hasSideEffects: false,
+    returnType: "number"
+  },
+  first: {
+    category: "collection",
+    minArity: 1,
+    maxArity: 1,
+    description: "Get first element",
+    hasSideEffects: false,
+    returnType: "any"
+  },
+  last: {
+    category: "collection",
+    minArity: 1,
+    maxArity: 1,
+    description: "Get last element",
+    hasSideEffects: false,
+    returnType: "any"
+  },
+  nth: {
+    category: "collection",
+    minArity: 2,
+    maxArity: 2,
+    description: "Get element at index",
+    hasSideEffects: false,
+    returnType: "any"
+  },
+  concat: {
+    category: "collection",
+    minArity: 2,
+    maxArity: null,
+    description: "Concatenate collections",
+    hasSideEffects: false,
+    returnType: "array"
+  },
+  includes: {
+    category: "collection",
+    minArity: 2,
+    maxArity: 2,
+    description: "Check if collection includes element",
+    hasSideEffects: false,
+    returnType: "boolean"
+  },
+  empty: {
+    category: "collection",
+    minArity: 1,
+    maxArity: 1,
+    description: "Check if collection is empty",
+    hasSideEffects: false,
+    returnType: "boolean"
+  }
+};
+function getOperatorMeta(operator) {
+  return OPERATORS[operator];
+}
+function isKnownOperator(operator) {
+  return operator in OPERATORS;
+}
+function isEffectOperator(operator) {
+  const meta = OPERATORS[operator];
+  return meta?.hasSideEffects ?? false;
+}
+function isGuardOperator(operator) {
+  const meta = OPERATORS[operator];
+  return meta !== void 0 && !meta.hasSideEffects;
+}
+function getOperatorsByCategory(category) {
+  return Object.entries(OPERATORS).filter(([_, meta]) => meta.category === category).map(([name]) => name);
+}
+function getAllOperators() {
+  return Object.keys(OPERATORS);
+}
+function validateOperatorArity(operator, argCount) {
+  const meta = OPERATORS[operator];
+  if (!meta) {
+    return `Unknown operator: ${operator}`;
+  }
+  if (argCount < meta.minArity) {
+    return `Operator '${operator}' requires at least ${meta.minArity} argument(s), got ${argCount}`;
+  }
+  if (meta.maxArity !== null && argCount > meta.maxArity) {
+    return `Operator '${operator}' accepts at most ${meta.maxArity} argument(s), got ${argCount}`;
+  }
+  return null;
+}
+var BindingSchema = z.string().refine(
+  (val) => {
+    if (!val.startsWith("@")) return false;
+    const parts = val.slice(1).split(".");
+    if (parts.length === 0 || parts[0] === "") return false;
+    return parts.every((part) => /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(part));
+  },
+  { message: "Invalid binding format. Must be @name or @name.path.to.field" }
+);
+var BINDING_DOCS = {
+  entity: {
+    description: "Reference to the linked entity for this trait",
+    examples: ["@entity.health", "@entity.x", "@entity.status"],
+    requiresPath: true
+  },
+  payload: {
+    description: "Reference to the event payload data",
+    examples: ["@payload.amount", "@payload.targetId", "@payload.action"],
+    requiresPath: true
+  },
+  state: {
+    description: "Current state machine state name",
+    examples: ["@state"],
+    requiresPath: false
+  },
+  now: {
+    description: "Current timestamp in milliseconds",
+    examples: ["@now"],
+    requiresPath: false
+  }
+};
+var BINDING_CONTEXT_RULES = {
+  guard: {
+    allowed: ["entity", "payload", "state", "now"],
+    description: "Guards can access entity fields, event payload, current state, and time"
+  },
+  effect: {
+    allowed: ["entity", "payload", "state", "now"],
+    description: "Effects can access and modify entity fields, use payload data"
+  },
+  tick: {
+    allowed: ["entity", "state", "now"],
+    description: "Ticks can access entity fields, current state, and time (no payload)"
+  }
+};
+function validateBindingInContext(binding, context) {
+  const rules = BINDING_CONTEXT_RULES[context];
+  if (binding.type === "core") {
+    if (!rules.allowed.includes(binding.root)) {
+      return `Binding @${binding.root} is not allowed in ${context} context. Allowed: ${rules.allowed.join(", ")}`;
+    }
+  }
+  return null;
+}
+function getBindingExamples(context) {
+  const rules = BINDING_CONTEXT_RULES[context];
+  const examples = [];
+  for (const binding of rules.allowed) {
+    const doc = BINDING_DOCS[binding];
+    examples.push(...doc.examples);
+  }
+  examples.push("@GameConfig.gravity", "@Filter.searchTerm");
+  return examples;
+}
+var InteractionModelSchema = z.object({
+  createFlow: z.enum(["modal", "page", "inline", "none"]),
+  editFlow: z.enum(["modal", "page", "inline", "none"]),
+  viewFlow: z.enum(["drawer", "page", "modal", "inline", "none"]),
+  deleteFlow: z.enum(["confirm", "instant", "none"]),
+  listInteraction: z.enum(["click-to-view", "click-to-edit", "inline-edit"]).optional(),
+  bulkActions: z.boolean().optional(),
+  realtime: z.boolean().optional()
+});
+var DEFAULT_INTERACTION_MODELS = {
+  business: {
+    createFlow: "modal",
+    editFlow: "modal",
+    viewFlow: "drawer",
+    deleteFlow: "confirm",
+    listInteraction: "click-to-view",
+    bulkActions: true
+  },
+  game: {
+    createFlow: "none",
+    editFlow: "none",
+    viewFlow: "none",
+    deleteFlow: "none",
+    realtime: true
+  },
+  form: {
+    createFlow: "inline",
+    editFlow: "inline",
+    viewFlow: "none",
+    deleteFlow: "none"
+  },
+  dashboard: {
+    createFlow: "modal",
+    editFlow: "modal",
+    viewFlow: "drawer",
+    deleteFlow: "confirm",
+    listInteraction: "click-to-view"
+  },
+  content: {
+    createFlow: "page",
+    editFlow: "page",
+    viewFlow: "page",
+    deleteFlow: "confirm",
+    listInteraction: "click-to-view"
+  }
+};
+function getInteractionModelForDomain(domain) {
+  return DEFAULT_INTERACTION_MODELS[domain] ?? DEFAULT_INTERACTION_MODELS.business;
+}
+var PATTERN_TYPES = [
+  // Display patterns
+  "entity-table",
+  "entity-list",
+  "entity-cards",
+  "entity-grid",
+  // Form patterns
+  "form",
+  "form-section",
+  // Header patterns
+  "page-header",
+  // Stats patterns
+  "stats",
+  "stat-card",
+  // Layout patterns
+  "master-detail",
+  "dashboard-grid",
+  // Game patterns
+  "game-canvas",
+  "game-hud",
+  "game-controls"
+];
+var PatternTypeSchema = z.string();
+function getAllPatternTypes() {
+  return [...PATTERN_TYPES];
+}
+function isValidPatternType(patternType) {
+  return PATTERN_TYPES.includes(patternType);
+}
+
+// src/types/ir.ts
+function createEmptyResolvedTrait(name, source) {
+  return {
+    name,
+    source,
+    states: [],
+    events: [],
+    transitions: [],
+    guards: [],
+    ticks: [],
+    listens: [],
+    dataEntities: []
+  };
+}
+function createEmptyResolvedPage(name) {
+  return {
+    name,
+    path: `/${name.toLowerCase()}`,
+    featureName: name.toLowerCase(),
+    sections: [],
+    traits: [],
+    entityBindings: [],
+    navigation: [],
+    singletonEntities: []
+  };
+}
+function inferTsType(schemaType) {
+  const typeMap = {
+    string: "string",
+    number: "number",
+    boolean: "boolean",
+    date: "Date",
+    datetime: "Date",
+    timestamp: "number",
+    array: "unknown[]",
+    object: "Record<string, unknown>",
+    any: "unknown"
+  };
+  if (schemaType.endsWith("[]")) {
+    const baseType = schemaType.slice(0, -2);
+    return `${typeMap[baseType] || baseType}[]`;
+  }
+  return typeMap[schemaType] || schemaType;
+}
+function createResolvedField(field) {
+  return {
+    name: field.name,
+    type: field.type,
+    tsType: inferTsType(field.type),
+    description: field.description,
+    default: field.default,
+    required: field.required ?? false,
+    validation: field.validation,
+    values: field.values
+  };
+}
+function isResolvedIR(ir) {
+  if (!ir || typeof ir !== "object") return false;
+  const r = ir;
+  return typeof r.appName === "string" && r.traits instanceof Map && r.pages instanceof Map;
+}
+
+export { ALLOWED_CUSTOM_COMPONENTS, AnimationDefSchema, AssetMapSchema, AssetMappingSchema, BINDING_CONTEXT_RULES, BINDING_DOCS, BindingSchema, CORE_BINDINGS, ComputedEventContractSchema, ComputedEventListenerSchema, CustomPatternDefinitionSchema, CustomPatternMapSchema, DEFAULT_INTERACTION_MODELS, DesignPreferencesSchema, DesignTokensSchema, DomainCategorySchema, DomainContextSchema, DomainVocabularySchema, ENTITY_ROLES, EffectSchema, EntityFieldSchema, EntityPersistenceSchema, EntityRefSchema, EntityRefStringSchema, EntityRoleSchema, EntitySchema, EntitySemanticRoleSchema, EventListenerSchema, EventPayloadFieldSchema, EventSchema, EventScopeSchema, EventSemanticRoleSchema, EventSourceSchema, ExpressionSchema, FieldFormatSchema, FieldSchema, FieldTypeSchema, GAME_TYPES, GameSubCategorySchema, GameTypeSchema, GuardSchema, InteractionModelSchema, McpServiceDefSchema, NodeClassificationSchema, OPERATORS, OPERATOR_CATEGORIES, OrbitalConfigSchema, OrbitalDefinitionSchema, OrbitalEntitySchema, OrbitalPageSchema, OrbitalPageStrictSchema, OrbitalSchemaSchema, OrbitalTraitRefSchema, OrbitalUnitSchema, OrbitalSchema as OrbitalZodSchema, PATTERN_TYPES, PageRefObjectSchema, PageRefSchema, PageRefStringSchema, PageSchema, PageTraitRefSchema, PatternTypeSchema, PayloadFieldSchema, RelatedLinkSchema, RelationConfigSchema, RequiredFieldSchema, ResolvedAssetSchema, RestAuthConfigSchema, RestServiceDefSchema, SERVICE_TYPES, SExprAtomSchema, SExprSchema, SemanticAssetRefSchema, ServiceDefinitionSchema, ServiceRefSchema, ServiceRefStringSchema, ServiceTypeSchema, SocketEventsSchema, SocketServiceDefSchema, StateMachineSchema, StateSchema, StateSemanticRoleSchema, SuggestedGuardSchema, ThemeDefinitionSchema, ThemeRefSchema, ThemeRefStringSchema, ThemeTokensSchema, ThemeVariantSchema, TraitCategorySchema, TraitDataEntitySchema, TraitEntityFieldSchema, TraitEventContractSchema, TraitEventListenerSchema, TraitRefSchema, TraitReferenceSchema, TraitSchema, TraitTickSchema, TransitionSchema, UISlotSchema, UI_SLOTS, UXHintsSchema, UseDeclarationSchema, UserPersonaSchema, VISUAL_STYLES, ViewTypeSchema, VisualStyleSchema, callService, collectBindings, createAssetKey, createEmptyResolvedPage, createEmptyResolvedTrait, createResolvedField, deriveCollection, despawn, doEffects, emit, findService, getAllOperators, getAllPatternTypes, getArgs, getBindingExamples, getDefaultAnimationsForRole, getInteractionModelForDomain, getOperator, getOperatorMeta, getOperatorsByCategory, getServiceNames, getTraitConfig, getTraitName, hasService, inferTsType, isBinding, isEffect, isEffectOperator, isEntityReference, isGuardOperator, isImportedTraitRef, isInlineTrait, isKnownOperator, isMcpService, isOrbitalDefinition, isPageReference, isPageReferenceObject, isPageReferenceString, isResolvedIR, isRestService, isRuntimeEntity, isSExpr, isSExprAtom, isSExprCall, isSExprEffect, isServiceReference, isSingletonEntity, isSocketService, isThemeReference, isValidBinding, isValidPatternType, navigate, normalizeTraitRef, notify, parseAssetKey, parseBinding, parseEntityRef, parseImportedTraitRef, parseOrbitalSchema, parsePageRef, parseServiceRef, persist, renderUI, safeParseOrbitalSchema, set, sexpr, spawn, validateAssetAnimations, validateBindingInContext, validateOperatorArity, walkSExpr };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map