@almadar/core 10.9.0 → 10.11.0

package/dist/factory-runtime/index.js

@@ -0,0 +1,1727 @@
+import { z } from 'zod';
+import '@almadar/patterns';
+
+// src/factory-runtime/extract-manifest.ts
+var STATIC_PARAM_FIELDS = [
+  {
+    name: "fields",
+    type: "EntityField[]",
+    description: "Extra fields appended to the canonical entity."
+  },
+  {
+    name: "pagePath",
+    type: "string",
+    description: "URL override for the orbital first page."
+  },
+  {
+    name: "persistence",
+    type: "'persistent' | 'runtime' | 'singleton' | 'instance' | 'local'",
+    description: "Override the canonical entity persistence mode."
+  },
+  {
+    name: "entityName",
+    type: "string",
+    description: "Rename the canonical entity. PascalCase singular, \u226432 chars. Threads through every trait's linkedEntity binding; compiler rewrites @Entity.x refs."
+  },
+  {
+    name: "collection",
+    type: "string",
+    description: "Override derived collection key. Defaults to plural(entityName).toLowerCase()."
+  },
+  {
+    name: "traitOverrides",
+    type: "Partial<Record<TraitName, { config?, linkedEntity?, events?, name?, emitsScope?, listens? }>>",
+    description: ".lolo's native trait-composition surface 1:1: per-imported-trait config, linkedEntity, events, name, emitsScope, listens. effects is excluded (atom-owned; use listens via a sibling trait)."
+  }
+];
+function splitTraits(traits) {
+  const refTraitNames = [];
+  const inlineTraitNames = [];
+  for (const t of traits) {
+    if (!t || typeof t !== "object") continue;
+    const tName = typeof t.name === "string" ? t.name : null;
+    if (!tName) continue;
+    if (typeof t.ref === "string") {
+      refTraitNames.push(tName);
+    } else {
+      inlineTraitNames.push(tName);
+    }
+  }
+  return { refTraitNames, inlineTraitNames };
+}
+function extractManifest(orb) {
+  const behaviorName = orb.name;
+  return orb.orbitals.map((orbital) => {
+    const { refTraitNames, inlineTraitNames } = splitTraits(orbital.traits);
+    return {
+      organism: behaviorName,
+      orbitalName: orbital.name,
+      paramFields: STATIC_PARAM_FIELDS,
+      traitNames: refTraitNames,
+      inlineTraitNames
+    };
+  });
+}
+z.enum([
+  "string",
+  "number",
+  "boolean",
+  "date",
+  "timestamp",
+  "datetime",
+  "array",
+  "object",
+  "enum",
+  "relation",
+  "trait",
+  "slot",
+  "pattern"
+]);
+var RelationCardinalitySchema = z.enum([
+  "one",
+  "many",
+  "one-to-many",
+  "many-to-one",
+  "many-to-many"
+]);
+var RelationConfigSchema = z.object({
+  entity: z.string().min(1, "Target entity is required"),
+  field: z.string().optional(),
+  cardinality: RelationCardinalitySchema.optional(),
+  onDelete: z.enum(["cascade", "nullify", "restrict"]).optional(),
+  // Legacy compatibility fields
+  foreignKey: z.string().optional(),
+  target: z.string().optional(),
+  type: RelationCardinalitySchema.optional()
+}).transform((data) => {
+  const normalized = {
+    entity: data.entity || data.target || "",
+    cardinality: data.cardinality || data.type,
+    field: data.field,
+    onDelete: data.onDelete
+  };
+  return normalized;
+});
+var FieldFormatSchema = z.enum([
+  "email",
+  "url",
+  "phone",
+  "date",
+  "datetime",
+  "uuid",
+  "image",
+  "avatar",
+  "thumbnail"
+]);
+var FIELD_TYPE_ALIASES = {
+  text: "string",
+  int: "number",
+  float: "number",
+  ts: "timestamp"
+};
+var EntityFieldSchema = z.lazy(() => {
+  const baseFieldShape = {
+    name: z.string().min(1, "Field name is required").optional(),
+    required: z.boolean().optional(),
+    default: z.unknown().optional(),
+    format: FieldFormatSchema.optional(),
+    min: z.number().optional(),
+    max: z.number().optional(),
+    properties: z.record(EntityFieldSchema).optional(),
+    intrinsic: z.boolean().optional(),
+    description: z.string().optional(),
+    synonyms: z.string().optional()
+  };
+  function scalarVariant(t) {
+    return z.object({
+      ...baseFieldShape,
+      type: z.literal(t),
+      values: z.array(z.string()).optional()
+    });
+  }
+  return z.preprocess(
+    (input) => {
+      if (input === null || typeof input !== "object" || !("type" in input) || typeof input.type !== "string") {
+        return input;
+      }
+      const obj = input;
+      const next = { ...obj };
+      const aliased = FIELD_TYPE_ALIASES[obj.type];
+      if (aliased !== void 0) next.type = aliased;
+      if (next.enum !== void 0 && next.values === void 0) {
+        next.values = next.enum;
+      }
+      delete next.enum;
+      return next;
+    },
+    z.discriminatedUnion("type", [
+      scalarVariant("string"),
+      scalarVariant("number"),
+      scalarVariant("boolean"),
+      scalarVariant("date"),
+      scalarVariant("timestamp"),
+      scalarVariant("datetime"),
+      scalarVariant("trait"),
+      scalarVariant("slot"),
+      scalarVariant("pattern"),
+      // Enum variant — REQUIRES non-empty values.
+      z.object({
+        ...baseFieldShape,
+        type: z.literal("enum"),
+        values: z.array(z.string()).min(1, "Enum field requires a non-empty `values` array")
+      }),
+      // Relation variant — REQUIRES relation config.
+      z.object({
+        ...baseFieldShape,
+        type: z.literal("relation"),
+        relation: RelationConfigSchema
+      }),
+      // Array variant — items optional to match relaxed TS shape.
+      z.object({
+        ...baseFieldShape,
+        type: z.literal("array"),
+        items: EntityFieldSchema.optional()
+      }),
+      // Object variant — fixed-key struct (`properties`) or dynamic-key
+      // map (`Map K V`, uniform value schema in `items`).
+      z.object({
+        ...baseFieldShape,
+        type: z.literal("object"),
+        items: EntityFieldSchema.optional(),
+        values: z.array(z.string()).optional()
+      })
+    ])
+  );
+});
+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 ASSET_DIMENSIONS = ["2d", "3d"];
+var AssetDimensionSchema = z.enum(ASSET_DIMENSIONS);
+var ASSET_ASPECTS = ["1:1", "16:9", "5:7", "8:1"];
+var AssetAspectSchema = z.enum(ASSET_ASPECTS);
+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(),
+  dimension: AssetDimensionSchema.optional(),
+  aspect: AssetAspectSchema.optional()
+});
+SemanticAssetRefSchema.extend({
+  url: z.string(),
+  name: z.string().optional(),
+  thumbnailUrl: z.string().optional()
+});
+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()
+});
+z.object({
+  gameType: GameTypeSchema,
+  style: VisualStyleSchema,
+  basePath: z.string(),
+  mappings: z.record(AssetMappingSchema)
+});
+var AssetCatalogEntrySchema = z.object({
+  url: z.string(),
+  name: z.string(),
+  category: z.string(),
+  kind: z.enum(["image", "spritesheet", "audio", "scene", "portrait", "model", "other"]),
+  thumbnailUrl: z.string().optional(),
+  dimension: AssetDimensionSchema.optional(),
+  aspect: AssetAspectSchema.optional()
+});
+z.array(AssetCatalogEntrySchema);
+
+// src/types/entity.ts
+var EntityPersistenceSchema = z.enum([
+  "persistent",
+  "runtime",
+  "singleton",
+  "instance",
+  "local"
+]);
+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"),
+  instances: z.array(z.record(z.unknown())).optional(),
+  timestamps: z.boolean().optional(),
+  softDelete: z.boolean().optional(),
+  description: z.string().optional(),
+  visual_prompt: z.string().optional(),
+  assetRef: SemanticAssetRefSchema.optional()
+});
+var EntitySchema = OrbitalEntitySchema;
+var UI_SLOTS = [
+  // App slots
+  "main",
+  "sidebar",
+  "modal",
+  "drawer",
+  "overlay",
+  "center",
+  "toast",
+  "floating",
+  "system",
+  // For invisible system components (InputListener, CollisionDetector)
+  "content",
+  "screen",
+  // Game HUD slots
+  "hud",
+  "hud-top",
+  "hud-bottom",
+  "hud.health",
+  "hud.score",
+  "hud.inventory",
+  "hud.stamina",
+  // Game overlay slots
+  "overlay.inventory",
+  "overlay.dialogue",
+  "overlay.menu",
+  "overlay.pause"
+];
+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" }
+);
+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;
+
+// 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.string().min(1),
+  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(),
+  synonyms: z.string().optional(),
+  tier: 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 TraitConfigValueSchema = z.lazy(
+  () => z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.null(),
+    z.array(TraitConfigValueSchema),
+    z.record(TraitConfigValueSchema)
+  ])
+);
+var TraitConfigSchema = z.record(TraitConfigValueSchema);
+function isCallSiteConfigDeclaration(entry) {
+  return typeof entry === "object" && entry !== null && !Array.isArray(entry) && "type" in entry && typeof entry.type === "string" && "default" in entry;
+}
+var ConfigFieldDeclarationSchema = z.object({
+  type: z.string(),
+  default: TraitConfigValueSchema.optional(),
+  label: z.string().optional(),
+  description: z.string().optional(),
+  tier: z.string().optional(),
+  values: z.array(z.string()).optional(),
+  synonyms: z.string().optional()
+});
+var DeclaredTraitConfigSchema = z.record(
+  ConfigFieldDeclarationSchema
+);
+var TraitCategorySchema = z.enum([
+  "lifecycle",
+  "temporal",
+  "validation",
+  "notification",
+  "integration",
+  "interaction",
+  "agent",
+  "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),
+  /**
+   * Field type. Mirrors the Rust validator's acceptance: any non-empty
+   * string. Primitives ('string' | 'number' | 'boolean' | 'object' |
+   * 'array') are the canonical values; entity-name references like
+   * 'ModalRecord' and array-of-entity references like '[ModalRecord]'
+   * are also valid because the Rust IR's PayloadField.field_type is
+   * just a String. Only enforced narrowly at the call site (e.g.
+   * emit-literal type-mismatch warnings in
+   * orbital-compiler/phases/validation/emit_payload.rs) — not here.
+   */
+  type: z.string().min(1),
+  required: z.boolean().optional(),
+  description: z.string().optional(),
+  entityType: z.string().optional()
+});
+var TraitEventContractSchema = z.object({
+  /**
+   * Event name. Mirrors the Rust validator's `is_valid_event_identifier`:
+   * starts with a letter, then any letters / digits / underscores. Both
+   * UPPER_SNAKE_CASE and PascalCase shapes are valid identifiers in the
+   * post-Phase 2.5 nominal-event type system (events declared via
+   * `type X = Event<T>`).
+   */
+  event: z.string().min(1).regex(
+    /^[A-Za-z][A-Za-z0-9_]*$/,
+    "Event name must start with a letter and contain only letters, digits, and underscores"
+  ),
+  description: z.string().optional(),
+  synonyms: z.string().optional(),
+  tier: z.string().optional(),
+  payloadSchema: z.array(EventPayloadFieldSchema).optional(),
+  scope: EventScopeSchema.optional()
+});
+var ListenSourceSchema = z.union([
+  z.object({ kind: z.literal("any") }),
+  z.object({ kind: z.literal("trait"), trait: z.string().min(1) }),
+  z.object({
+    kind: z.literal("orbital"),
+    orbital: z.string().min(1),
+    trait: z.string().min(1)
+  })
+]);
+var TraitEventListenerSchema = z.object({
+  event: z.string().min(1),
+  triggers: z.string().min(1),
+  description: z.string().optional(),
+  synonyms: z.string().optional(),
+  tier: z.string().optional(),
+  guard: ExpressionSchema.optional(),
+  scope: EventScopeSchema.optional(),
+  payloadMapping: z.record(z.string()).optional(),
+  source: ListenSourceSchema.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()
+});
+z.object({
+  ref: z.string().min(1),
+  // Phase 1.2: optional registry path disambiguator, pairs with `ref`.
+  from: z.string().optional(),
+  linkedEntity: z.string().optional(),
+  name: z.string().optional(),
+  events: z.record(
+    z.string().min(1, "events key (atom event name) must be non-empty"),
+    z.string().min(1, "events value (caller event name) must be non-empty")
+  ).optional(),
+  fields: z.record(
+    z.string().min(1, "fields key (canonical field name) must be non-empty"),
+    z.string().min(1, "fields value (consumer field name) must be non-empty")
+  ).optional(),
+  // Each value is either a plain wiring value (TraitConfigValue) or an
+  // annotated ConfigFieldDeclaration. Declaration form is tried first
+  // (it's more specific — has a `"type"` string key); plain values fall
+  // through to the recursive TraitConfigValue union.
+  config: z.record(z.union([ConfigFieldDeclarationSchema, TraitConfigValueSchema])).optional(),
+  appliesTo: z.array(z.string()).optional(),
+  // Phase F.7: zod accepts an array (the inliner validates element
+  // shape). The full ListenDefinition shape isn't recursively encoded
+  // here because TraitReference is the call-site form — listen entries
+  // pasted in are already-resolved structured definitions, not nested
+  // overrides.
+  listens: z.array(z.unknown()).optional(),
+  emitsScope: z.enum(["internal", "external"]).optional(),
+  // Phase F.8: per-transition effects override. The keys are event
+  // names (the transition triggers AFTER renames). Values are arrays
+  // of SExpression-shaped data; the inliner validates the SExpression
+  // shape during application, so the schema accepts loose `unknown[]`.
+  effects: z.record(
+    z.string().min(1, "effects override key (event name) must be non-empty"),
+    z.array(z.unknown())
+  ).optional()
+}).refine(
+  (ref2) => {
+    if (!ref2.events) return true;
+    for (const [from, to] of Object.entries(ref2.events)) {
+      if (from.length === 0 || to.length === 0) return false;
+    }
+    return true;
+  },
+  {
+    message: 'TraitReference "events" entries must have non-empty atom and caller event names',
+    path: ["events"]
+  }
+);
+var TraitScopeSchema = z.enum(["instance", "collection"]);
+var EntityFieldContractSchema = z.object({
+  requires: z.array(z.string()),
+  provides: z.array(z.string())
+});
+var SourceBehaviorMetadataSchema = z.object({
+  behavior: z.string().min(1),
+  alias: z.string().min(1),
+  originalName: z.string().min(1)
+});
+var TraitSchema = z.object({
+  name: z.string().min(1),
+  description: z.string().optional(),
+  description_visual_prompt: z.string().optional(),
+  category: TraitCategorySchema.optional(),
+  entityRebindable: z.boolean().optional(),
+  entityContract: EntityFieldContractSchema.optional(),
+  entityBindingDescription: z.string().optional(),
+  entityBindingSynonyms: z.string().optional(),
+  capabilities: z.array(z.string()).optional(),
+  scope: TraitScopeSchema,
+  linkedEntity: z.string().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(),
+  config: DeclaredTraitConfigSchema.optional(),
+  sourceBehavior: SourceBehaviorMetadataSchema.optional(),
+  sourceEntityDefinition: EntitySchema.optional()
+});
+var TraitRefSchema = z.union([
+  z.string().min(1),
+  z.object({
+    ref: z.string().min(1),
+    config: TraitConfigSchema.optional(),
+    linkedEntity: z.string().optional(),
+    name: z.string().optional(),
+    // Phase F.4: same non-empty refine as TraitReferenceSchema.events.
+    // Both schemas accept the same call-site argument shape, so the
+    // validators should agree.
+    events: z.record(
+      z.string().min(1, "events key (atom event name) must be non-empty"),
+      z.string().min(1, "events value (caller event name) must be non-empty")
+    ).optional()
+  }),
+  TraitSchema
+  // Allow inline trait definitions
+]);
+
+// src/types/page.ts
+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: TraitConfigSchema.optional()
+});
+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;
+z.enum([
+  "healthcare",
+  "education",
+  "finance",
+  "ecommerce",
+  "real-estate",
+  "logistics",
+  "hospitality",
+  "hr-management",
+  "project-management",
+  "social",
+  "content-management",
+  "iot",
+  "analytics",
+  "game",
+  "custom"
+]);
+var AGENT_DOMAIN_CATEGORIES = [
+  "game",
+  "business",
+  "dashboard",
+  "form",
+  "content",
+  "social",
+  "ecommerce",
+  "workflow"
+];
+var AgentDomainCategorySchema = z.enum([...AGENT_DOMAIN_CATEGORIES]);
+z.enum([
+  "platformer",
+  "shooter",
+  "puzzle",
+  "rpg",
+  "board",
+  "racing",
+  "fighting",
+  "tower-defense",
+  "endless-runner",
+  "simulation",
+  "arcade",
+  "adventure"
+]);
+z.enum(["domain", "system"]);
+z.enum([
+  "pending",
+  "active",
+  "completed",
+  "cancelled",
+  "error",
+  "suspended",
+  "blocked",
+  "domain_workflow",
+  "domain_status",
+  "system_loading",
+  "system_error",
+  "system_idle",
+  "system_editing",
+  "system_confirming"
+]);
+z.enum([
+  "domain_action",
+  "domain_trigger",
+  "system_crud",
+  "system_navigation",
+  "system_form",
+  "system_ui"
+]);
+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: AgentDomainCategorySchema,
+  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 SpacingScaleSchema = z.object({
+  space0: z.string().optional(),
+  space1: z.string().optional(),
+  space2: z.string().optional(),
+  space3: z.string().optional(),
+  space4: z.string().optional(),
+  space5: z.string().optional(),
+  space6: z.string().optional(),
+  space7: z.string().optional(),
+  space8: z.string().optional(),
+  space9: z.string().optional(),
+  space10: z.string().optional(),
+  space11: z.string().optional(),
+  space12: z.string().optional()
+});
+var DensityTokensSchema = z.object({
+  spacing: SpacingScaleSchema.optional(),
+  buttonHeightSm: z.string().optional(),
+  buttonHeightMd: z.string().optional(),
+  buttonHeightLg: z.string().optional(),
+  inputHeightSm: z.string().optional(),
+  inputHeightMd: z.string().optional(),
+  inputHeightLg: z.string().optional(),
+  rowHeightCompact: z.string().optional(),
+  rowHeightNormal: z.string().optional(),
+  rowHeightSpacious: z.string().optional(),
+  cardPaddingSm: z.string().optional(),
+  cardPaddingMd: z.string().optional(),
+  cardPaddingLg: z.string().optional(),
+  dialogPadding: z.string().optional(),
+  sectionGap: z.string().optional()
+});
+var TypeScaleEntrySchema = z.object({
+  size: z.string(),
+  lineHeight: z.string()
+});
+var TypeSlotSchema = z.enum(["display", "body", "mono"]);
+var TypeSizeKeySchema = z.enum([
+  "xs",
+  "sm",
+  "base",
+  "lg",
+  "xl",
+  "2xl",
+  "3xl",
+  "4xl",
+  "display-1",
+  "display-2"
+]);
+var TypeWeightSchema = z.enum(["normal", "medium", "bold"]);
+var TypeIntentSchema = z.object({
+  slot: TypeSlotSchema,
+  size: TypeSizeKeySchema,
+  weight: TypeWeightSchema
+});
+var TypeScaleSchema = z.object({
+  xs: TypeScaleEntrySchema.optional(),
+  sm: TypeScaleEntrySchema.optional(),
+  base: TypeScaleEntrySchema.optional(),
+  lg: TypeScaleEntrySchema.optional(),
+  xl: TypeScaleEntrySchema.optional(),
+  "2xl": TypeScaleEntrySchema.optional(),
+  "3xl": TypeScaleEntrySchema.optional(),
+  "4xl": TypeScaleEntrySchema.optional(),
+  "display-1": TypeScaleEntrySchema.optional(),
+  "display-2": TypeScaleEntrySchema.optional()
+});
+var TypeIntentMapSchema = z.object({
+  headingMajor: TypeIntentSchema.optional(),
+  headingMinor: TypeIntentSchema.optional(),
+  bodyEmphasis: TypeIntentSchema.optional(),
+  bodyDefault: TypeIntentSchema.optional(),
+  bodyQuiet: TypeIntentSchema.optional(),
+  caption: TypeIntentSchema.optional(),
+  numeric: TypeIntentSchema.optional()
+});
+var TypeScaleTokensSchema = z.object({
+  displayFamily: z.string().optional(),
+  bodyFamily: z.string().optional(),
+  monoFamily: z.string().optional(),
+  scale: TypeScaleSchema.optional(),
+  intents: TypeIntentMapSchema.optional()
+});
+var MotionDurationKeySchema = z.enum([
+  "instant",
+  "fast",
+  "normal",
+  "slow",
+  "dramatic"
+]);
+var MotionEasingKeySchema = z.enum([
+  "linear",
+  "standard",
+  "emphasized",
+  "spring"
+]);
+var MotionIntentSchema = z.object({
+  duration: MotionDurationKeySchema,
+  easing: MotionEasingKeySchema
+});
+var MotionDurationPaletteSchema = z.object({
+  instant: z.string().optional(),
+  fast: z.string().optional(),
+  normal: z.string().optional(),
+  slow: z.string().optional(),
+  dramatic: z.string().optional()
+});
+var MotionEasingPaletteSchema = z.object({
+  linear: z.string().optional(),
+  standard: z.string().optional(),
+  emphasized: z.string().optional(),
+  spring: z.string().optional()
+});
+var MotionIntentMapSchema = z.object({
+  enter: MotionIntentSchema.optional(),
+  exit: MotionIntentSchema.optional(),
+  hover: MotionIntentSchema.optional(),
+  press: MotionIntentSchema.optional(),
+  expand: MotionIntentSchema.optional(),
+  transition: MotionIntentSchema.optional()
+});
+var MotionTokensSchema = z.object({
+  durations: MotionDurationPaletteSchema.optional(),
+  easings: MotionEasingPaletteSchema.optional(),
+  intents: MotionIntentMapSchema.optional()
+});
+var IconFamilySchema = z.enum([
+  "lucide",
+  "phosphor-outline",
+  "phosphor-fill",
+  "phosphor-duotone",
+  "tabler",
+  "fa-solid"
+]);
+var IconographyTokensSchema = z.object({
+  family: IconFamilySchema.optional(),
+  strokeWidth: z.string().optional(),
+  defaultSize: z.string().optional()
+});
+var ElevationTokensSchema = z.object({
+  cardElevation: z.string().optional(),
+  popoverElevation: z.string().optional(),
+  dialogElevation: z.string().optional(),
+  toastElevation: z.string().optional()
+});
+var GeometryTokensSchema = z.object({
+  radiusContainer: z.string().optional(),
+  radiusInteractive: z.string().optional(),
+  radiusPill: z.string().optional(),
+  borderHairline: z.string().optional(),
+  borderStandard: z.string().optional(),
+  borderHeavy: z.string().optional()
+});
+var ColorTokensSchema = z.object({
+  primary: z.string().optional(),
+  primaryHover: z.string().optional(),
+  primaryForeground: z.string().optional(),
+  secondary: z.string().optional(),
+  secondaryHover: z.string().optional(),
+  secondaryForeground: z.string().optional(),
+  accent: z.string().optional(),
+  accentForeground: z.string().optional(),
+  muted: z.string().optional(),
+  mutedForeground: z.string().optional(),
+  background: z.string().optional(),
+  foreground: z.string().optional(),
+  card: z.string().optional(),
+  cardForeground: z.string().optional(),
+  surface: z.string().optional(),
+  border: z.string().optional(),
+  input: z.string().optional(),
+  ring: z.string().optional(),
+  error: z.string().optional(),
+  errorForeground: z.string().optional(),
+  success: z.string().optional(),
+  successForeground: z.string().optional(),
+  warning: z.string().optional(),
+  warningForeground: z.string().optional(),
+  info: z.string().optional(),
+  infoForeground: z.string().optional(),
+  tableHeader: z.string().optional(),
+  tableBorder: z.string().optional(),
+  tableRowHover: z.string().optional(),
+  surfaceHover: z.string().optional(),
+  borderHover: z.string().optional(),
+  placeholder: z.string().optional()
+});
+var IllustrationStyleSchema = z.enum([
+  "minimal",
+  "illustrated",
+  "photo",
+  "text-only",
+  "mascot"
+]);
+var IllustrationTokensSchema = z.object({
+  style: IllustrationStyleSchema.optional(),
+  emptyAsset: z.string().optional(),
+  loadingAsset: z.string().optional(),
+  errorAsset: z.string().optional(),
+  onboardingAsset: z.string().optional()
+});
+var ThemeTokensSchema = z.object({
+  color: ColorTokensSchema.optional(),
+  density: DensityTokensSchema.optional(),
+  typeScale: TypeScaleTokensSchema.optional(),
+  motion: MotionTokensSchema.optional(),
+  iconography: IconographyTokensSchema.optional(),
+  elevation: ElevationTokensSchema.optional(),
+  geometry: GeometryTokensSchema.optional(),
+  illustration: IllustrationTokensSchema.optional(),
+  // Legacy
+  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({
+  color: ColorTokensSchema.optional(),
+  density: DensityTokensSchema.optional(),
+  typeScale: TypeScaleTokensSchema.optional(),
+  motion: MotionTokensSchema.optional(),
+  iconography: IconographyTokensSchema.optional(),
+  elevation: ElevationTokensSchema.optional(),
+  geometry: GeometryTokensSchema.optional(),
+  illustration: IllustrationTokensSchema.optional(),
+  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()
+});
+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"];
+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
+]);
+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 ServiceRefObjectSchema = z.object({
+  ref: ServiceRefStringSchema,
+  description: z.string().optional(),
+  baseUrl: z.string().url("baseUrl override must be a valid URL").optional(),
+  headers: z.record(z.string()).optional(),
+  url: z.string().url("url override must be a valid URL").optional(),
+  serverPath: z.string().optional()
+});
+var ServiceRefSchema = z.union([
+  ServiceDefinitionSchema,
+  ServiceRefObjectSchema,
+  ServiceRefStringSchema
+]);
+
+// 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")'
+  )
+});
+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 EntityCallSchema = z.object({
+  extends: z.string().regex(
+    /^[A-Z][a-zA-Z0-9]*\.entity$/,
+    'EntityCall "extends" must be in format "Alias.entity"'
+  ),
+  name: z.string().optional(),
+  fields: z.array(EntityFieldSchema).optional(),
+  persistence: EntityPersistenceSchema.optional(),
+  collection: z.string().optional()
+}).refine(
+  (call) => {
+    if (!call.fields) return true;
+    const seen = /* @__PURE__ */ new Set();
+    for (const field of call.fields) {
+      if (field.name === void 0) continue;
+      if (seen.has(field.name)) return false;
+      seen.add(field.name);
+    }
+    return true;
+  },
+  {
+    message: 'EntityCall "fields" override list must not contain duplicate field names',
+    path: ["fields"]
+  }
+);
+var EntityRefSchema = z.union([
+  EntitySchema,
+  EntityRefStringSchema,
+  EntityCallSchema
+]);
+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,
+  // Phase 1.2: optional registry path disambiguator, pairs with `ref`.
+  from: z.string().optional(),
+  path: z.string().startsWith("/").optional(),
+  linkedEntity: z.string().optional(),
+  traits: z.array(TraitRefSchema).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"'
+);
+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;
+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 ConfigProvenanceRecordSchema = z.object({
+  trait: z.string(),
+  patternPath: z.string().optional(),
+  prop: z.string(),
+  knob: z.string()
+});
+var SchemaMetadataSchema = z.object({
+  version: z.number().optional(),
+  createdAt: z.number().optional(),
+  source: z.string().optional(),
+  updatedAt: z.number().optional(),
+  configProvenance: z.record(z.array(ConfigProvenanceRecordSchema)).optional()
+});
+z.object({
+  name: z.string().min(1, "Schema name is required"),
+  description: z.string().optional(),
+  summary: 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(),
+  _metadata: SchemaMetadataSchema.optional()
+});
+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) => /^[\p{L}_][\p{L}0-9_]*$/u.test(part));
+  },
+  { message: "Invalid binding format. Must be @name or @name.path.to.field" }
+);
+var BINDING_ROOTS = [
+  "entity",
+  "payload",
+  "state",
+  "config",
+  "user",
+  "trait",
+  "item",
+  "now",
+  "computed",
+  "other"
+];
+new Set(BINDING_ROOTS.filter((r) => r !== "other"));
+var TRAIT_REF_PATTERN = /^@trait\.[A-Z][a-zA-Z0-9]*$/;
+z.string().regex(TRAIT_REF_PATTERN, "expected `@trait.<TraitName>` reference");
+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()
+});
+z.string();
+
+// src/builders.ts
+function makeTraitRef(opts) {
+  const ref2 = { ref: opts.ref };
+  if (opts.from !== void 0) ref2.from = opts.from;
+  if (opts.name !== void 0) ref2.name = opts.name;
+  if (opts.linkedEntity !== void 0) ref2.linkedEntity = opts.linkedEntity;
+  if (opts.events !== void 0) ref2.events = opts.events;
+  if (opts.fields !== void 0) ref2.fields = opts.fields;
+  if (opts.effects !== void 0) ref2.effects = opts.effects;
+  if (opts.listens !== void 0) ref2.listens = opts.listens;
+  if (opts.emitsScope !== void 0) ref2.emitsScope = opts.emitsScope;
+  if (opts.config !== void 0) ref2.config = opts.config;
+  return ref2;
+}
+function makePageRef(opts) {
+  const ref2 = { ref: opts.ref };
+  if (opts.from !== void 0) ref2.from = opts.from;
+  if (opts.path !== void 0) ref2.path = opts.path;
+  if (opts.linkedEntity !== void 0) ref2.linkedEntity = opts.linkedEntity;
+  if (opts.traits !== void 0) ref2.traits = opts.traits;
+  return ref2;
+}
+function makeOrbitalWithUses(opts) {
+  const orbital = {
+    name: opts.name,
+    uses: opts.uses,
+    entity: opts.entity,
+    traits: opts.traits,
+    pages: opts.pages ?? []
+  };
+  return orbital;
+}
+
+// src/factory-runtime/apply-params-to-orb.ts
+function validateOrbitalFactoryParams(manifest, raw) {
+  if (raw === null || Array.isArray(raw)) {
+    return {
+      ok: false,
+      error: { kind: "not-object", received: Array.isArray(raw) ? "array" : "null" }
+    };
+  }
+  const ALLOWED_KEYS = /* @__PURE__ */ new Set([
+    "fields",
+    "pagePath",
+    "persistence",
+    "entityName",
+    "collection",
+    "traitOverrides"
+  ]);
+  for (const key of Object.keys(raw)) {
+    if (!ALLOWED_KEYS.has(key)) {
+      return { ok: false, error: { kind: "unknown-key", key } };
+    }
+  }
+  const candidate = raw;
+  if (candidate.traitOverrides !== void 0) {
+    const to = candidate.traitOverrides;
+    if (to === null || typeof to !== "object" || Array.isArray(to)) {
+      return {
+        ok: false,
+        error: {
+          kind: "trait-overrides-not-object",
+          received: Array.isArray(to) ? "array" : typeof to
+        }
+      };
+    }
+    const allowed = new Set(manifest.traitNames);
+    for (const traitName of Object.keys(to)) {
+      if (!allowed.has(traitName)) {
+        return {
+          ok: false,
+          error: {
+            kind: "unknown-trait-override",
+            trait: traitName,
+            allowed: manifest.traitNames
+          }
+        };
+      }
+    }
+  }
+  return { ok: true, params: candidate };
+}
+function assertResolvedEntity(entity, orbitalName, orbName) {
+  if (typeof entity === "string") {
+    throw new Error(
+      `applyParamsToOrb: orbital "${orbitalName}" in orb "${orbName}" has an unresolved entity reference (string form). Pass a resolved .orb.`
+    );
+  }
+  if ("extends" in entity) {
+    throw new Error(
+      `applyParamsToOrb: orbital "${orbitalName}" in orb "${orbName}" has an unresolved EntityCall ("extends" form). Pass a resolved .orb.`
+    );
+  }
+  return entity;
+}
+function findOrbitalOrThrow(orb, orbitalName) {
+  const orbital = orb.orbitals.find((o) => o.name === orbitalName);
+  if (!orbital) {
+    throw new Error(
+      `applyParamsToOrb: orbital "${orbitalName}" not found in orb "${orb.name}". Available: ${orb.orbitals.map((o) => o.name).join(", ")}`
+    );
+  }
+  return orbital;
+}
+function buildEntity(ctx, effectiveName, effectiveCollection, params) {
+  const canonicalFields = Array.isArray(ctx.canonicalEntity.fields) ? ctx.canonicalEntity.fields : [];
+  const extras = params.fields ?? [];
+  for (const f of extras) {
+    if (f.type === "enum") {
+      if (!Array.isArray(f.values) || f.values.length === 0) {
+        throw new Error(
+          `Field "${f.name ?? "<unnamed>"}" (type: "enum") requires a non-empty \`values: string[]\` array. Got: ${f.values === void 0 ? "undefined" : JSON.stringify(f.values)}.`
+        );
+      }
+    }
+    if (f.type === "relation") {
+      const rel = f.relation;
+      if (!rel || typeof rel.entity !== "string" || rel.entity.length === 0) {
+        throw new Error(
+          `Field "${f.name ?? "<unnamed>"}" (type: "relation") requires \`relation: { entity: <EntityName>, cardinality: "one" | "many" }\`. Got: ${rel === void 0 ? "undefined" : JSON.stringify(rel)}.`
+        );
+      }
+      if (rel.cardinality !== "one" && rel.cardinality !== "many") {
+        throw new Error(
+          `Field "${f.name ?? "<unnamed>"}" (type: "relation") requires \`relation.cardinality: "one" | "many"\`. Got: ${rel.cardinality === void 0 ? "undefined" : JSON.stringify(rel.cardinality)}.`
+        );
+      }
+    }
+  }
+  let mergedFields;
+  if (extras.length === 0) {
+    mergedFields = canonicalFields;
+  } else {
+    const extraNames = new Set(extras.map((f) => f.name));
+    mergedFields = [
+      ...canonicalFields.filter((f) => !extraNames.has(f.name)),
+      ...extras
+    ];
+  }
+  const entity = {
+    name: effectiveName,
+    persistence: params.persistence ?? ctx.canonicalEntity.persistence,
+    fields: [...mergedFields]
+  };
+  if (effectiveCollection !== void 0) {
+    entity.collection = effectiveCollection;
+  }
+  return entity;
+}
+function isTraitReferenceObject(t) {
+  if (t === null || typeof t !== "object") return false;
+  if (!("ref" in t)) return false;
+  return typeof t.ref === "string";
+}
+function isPageRefObject(p) {
+  if (p === null || typeof p !== "object") return false;
+  if (!("ref" in p)) return false;
+  return typeof p.ref === "string";
+}
+function rewriteInlineLinkedEntity(shape, oldName, newName) {
+  if (shape.linkedEntity !== oldName) return shape;
+  return { ...shape, linkedEntity: newName };
+}
+var ENTITY_POSITIONAL_OPS = [
+  { op: "fetch", entityIndex: 1 },
+  { op: "ref", entityIndex: 1 },
+  { op: "spawn", entityIndex: 1 },
+  { op: "persist", actionGuard: /* @__PURE__ */ new Set(["create", "update", "delete"]), entityIndex: 2 }
+];
+var ENTITY_VALUED_PROPS = /* @__PURE__ */ new Set([
+  "entity",
+  "source",
+  "entityType",
+  "linkedEntity"
+]);
+function rewriteEntityInSExpr(value, oldName, newName) {
+  if (value === null) return null;
+  if (typeof value === "boolean" || typeof value === "number") return value;
+  if (typeof value === "string") {
+    const prefix = `@${oldName}`;
+    if (value === prefix || value.startsWith(`${prefix}.`)) {
+      return `@${newName}${value.slice(prefix.length)}`;
+    }
+    return value;
+  }
+  if (Array.isArray(value)) {
+    const first = value[0];
+    if (typeof first === "string") {
+      for (const entry of ENTITY_POSITIONAL_OPS) {
+        if (first !== entry.op) continue;
+        if (entry.actionGuard !== void 0) {
+          const action = value[1];
+          if (typeof action !== "string" || !entry.actionGuard.has(action)) continue;
+        }
+        const at = entry.entityIndex;
+        const slot = value[at];
+        if (typeof slot !== "string" || slot !== oldName) continue;
+        const rewritten = [];
+        for (let i = 0; i < value.length; i++) {
+          rewritten.push(i === at ? newName : rewriteEntityInSExpr(value[i], oldName, newName));
+        }
+        return rewritten;
+      }
+    }
+    return value.map((v) => rewriteEntityInSExpr(v, oldName, newName));
+  }
+  return rewriteEntityInSExprMap(value, oldName, newName);
+}
+function rewriteEntityInSExprMap(obj, oldName, newName) {
+  const next = {};
+  for (const [k, v] of Object.entries(obj)) {
+    if (ENTITY_VALUED_PROPS.has(k) && typeof v === "string" && v === oldName) {
+      next[k] = newName;
+    } else {
+      next[k] = rewriteEntityInSExpr(v, oldName, newName);
+    }
+  }
+  return next;
+}
+function rewritePayloadFieldType(typeStr, oldName, newName) {
+  if (typeStr === oldName) return newName;
+  if (typeStr === `[${oldName}]`) return `[${newName}]`;
+  return typeStr;
+}
+function rewriteEventContract(contract, oldName, newName) {
+  if (!contract.payloadSchema || contract.payloadSchema.length === 0) return contract;
+  return {
+    ...contract,
+    payloadSchema: contract.payloadSchema.map((f) => {
+      const next = { ...f, type: rewritePayloadFieldType(f.type, oldName, newName) };
+      if (typeof f.entityType === "string" && f.entityType === oldName) {
+        next.entityType = newName;
+      }
+      return next;
+    })
+  };
+}
+function rewriteListener(listener, oldName, newName) {
+  if (!listener.payloadMapping) return listener;
+  const prefix = `@${oldName}`;
+  const nextMapping = {};
+  for (const [k, v] of Object.entries(listener.payloadMapping)) {
+    nextMapping[k] = v === prefix || v.startsWith(`${prefix}.`) ? `@${newName}${v.slice(prefix.length)}` : v;
+  }
+  return { ...listener, payloadMapping: nextMapping };
+}
+function rewriteTick(tick, oldName, newName) {
+  const next = { ...tick };
+  if (next.guard !== void 0 && next.guard !== null) {
+    next.guard = rewriteEntityInSExpr(next.guard, oldName, newName);
+  }
+  next.effects = next.effects.map(
+    (e) => rewriteEntityInSExpr(e, oldName, newName)
+  );
+  return next;
+}
+function rebindInlineTraitEntity(trait, oldName, newName) {
+  if (oldName === newName) return trait;
+  return rewriteEntityInInlineTrait(rewriteInlineLinkedEntity(trait, oldName, newName), oldName, newName);
+}
+function rewriteEntityInInlineTrait(trait, oldName, newName) {
+  if (oldName === newName) return trait;
+  const next = { ...trait };
+  if (next.stateMachine) {
+    next.stateMachine = {
+      ...next.stateMachine,
+      transitions: next.stateMachine.transitions.map((t) => {
+        const updated = { ...t };
+        if (updated.guard !== void 0 && updated.guard !== null) {
+          updated.guard = rewriteEntityInSExpr(updated.guard, oldName, newName);
+        }
+        if (updated.effects) {
+          updated.effects = updated.effects.map(
+            (e) => rewriteEntityInSExpr(e, oldName, newName)
+          );
+        }
+        return updated;
+      })
+    };
+  }
+  if (next.initialEffects) {
+    next.initialEffects = next.initialEffects.map(
+      (e) => rewriteEntityInSExpr(e, oldName, newName)
+    );
+  }
+  if (next.ticks) {
+    next.ticks = next.ticks.map((t) => rewriteTick(t, oldName, newName));
+  }
+  if (next.emits) {
+    next.emits = next.emits.map((c) => rewriteEventContract(c, oldName, newName));
+  }
+  if (next.listens) {
+    next.listens = next.listens.map((l) => rewriteListener(l, oldName, newName));
+  }
+  return next;
+}
+function rebuildTraits(ctx, effectiveEntityName, traits) {
+  return traits.map((t) => {
+    if (!isTraitReferenceObject(t)) {
+      if (typeof t === "string") return t;
+      return rebindInlineTraitEntity(t, ctx.canonicalEntityName, effectiveEntityName);
+    }
+    const rewrittenLinkedEntity = t.linkedEntity === ctx.canonicalEntityName ? effectiveEntityName : t.linkedEntity;
+    const opts = {
+      ...t,
+      linkedEntity: rewrittenLinkedEntity
+    };
+    return makeTraitRef(opts);
+  });
+}
+function rebuildPages(ctx, effectiveEntityName, pages) {
+  if (!pages) return [];
+  return pages.map((p) => {
+    if (!isPageRefObject(p)) {
+      return p;
+    }
+    const rewrittenLinkedEntity = p.linkedEntity === ctx.canonicalEntityName ? effectiveEntityName : p.linkedEntity;
+    const opts = {
+      ...p,
+      linkedEntity: rewrittenLinkedEntity
+    };
+    return makePageRef(opts);
+  });
+}
+function mergeCallSiteConfigOverrides(base, overrides) {
+  const next = {};
+  for (const [k, entry] of Object.entries(base)) {
+    next[k] = isCallSiteConfigDeclaration(entry) ? entry : { type: "unknown", default: entry };
+  }
+  for (const [k, v] of Object.entries(overrides)) {
+    if (isCallSiteConfigDeclaration(v)) {
+      next[k] = v;
+      continue;
+    }
+    const existing = base[k];
+    next[k] = existing !== void 0 && isCallSiteConfigDeclaration(existing) ? { ...existing, default: v } : { type: "unknown", default: v };
+  }
+  return next;
+}
+function applyParamsToOrb(orb, orbitalName, _manifest, params) {
+  const orbital = findOrbitalOrThrow(orb, orbitalName);
+  const canonicalEntity = assertResolvedEntity(orbital.entity, orbitalName, orb.name);
+  const canonicalEntityName = canonicalEntity.name;
+  const effectiveEntityName = params.entityName ?? canonicalEntityName;
+  const effectiveCollection = typeof canonicalEntity.collection === "string" ? params.collection ?? (params.entityName ? `${params.entityName.toLowerCase()}s` : canonicalEntity.collection) : params.collection;
+  const ctx = { canonicalEntityName, canonicalEntity };
+  const built = makeOrbitalWithUses({
+    name: orbital.name,
+    uses: orbital.uses ?? [],
+    entity: buildEntity(ctx, effectiveEntityName, effectiveCollection, params),
+    traits: rebuildTraits(ctx, effectiveEntityName, orbital.traits),
+    pages: rebuildPages(ctx, effectiveEntityName, orbital.pages)
+  });
+  if (built.traits && params.traitOverrides !== void 0) {
+    built.traits = built.traits.map((t) => {
+      if (!isTraitReferenceObject(t) || typeof t.name !== "string") return t;
+      const override = params.traitOverrides?.[t.name];
+      if (!override) return t;
+      const merged = { ...t };
+      if (override.config !== void 0) {
+        merged.config = mergeCallSiteConfigOverrides(t.config ?? {}, override.config);
+      }
+      if (override.linkedEntity !== void 0) merged.linkedEntity = override.linkedEntity;
+      if (override.events !== void 0) {
+        if (override.events === null || typeof override.events !== "object" || Array.isArray(override.events)) {
+          throw new Error(
+            `traitOverrides["${t.name}"].events must be a Record<string,string> (rename map like { "OPEN": "ADD_ITEM" }), got ${Array.isArray(override.events) ? "an array" : typeof override.events}`
+          );
+        }
+        for (const [k, v] of Object.entries(override.events)) {
+          if (typeof v !== "string") {
+            throw new Error(
+              `traitOverrides["${t.name}"].events["${k}"] must be a string (target event name), got ${typeof v}`
+            );
+          }
+        }
+        merged.events = { ...t.events ?? {}, ...override.events };
+      }
+      if (override.name !== void 0) merged.name = override.name;
+      if (override.emitsScope !== void 0) merged.emitsScope = override.emitsScope;
+      if (override.listens !== void 0) merged.listens = override.listens;
+      return merged;
+    });
+  }
+  if (built.pages && params.pagePath !== void 0) {
+    built.pages = built.pages.map((p, idx) => {
+      if (!isPageRefObject(p) || idx !== 0) return p;
+      return { ...p, path: params.pagePath };
+    });
+  }
+  return built;
+}
+
+// src/factory-runtime/apply-params-to-whole-orb.ts
+function applyParamsToWholeOrb(orb, manifests, params) {
+  const manifestByOrbital = /* @__PURE__ */ new Map();
+  for (const m of manifests) {
+    manifestByOrbital.set(m.orbitalName, m);
+  }
+  const rebuilt = [];
+  for (const orbital of orb.orbitals) {
+    const manifest = manifestByOrbital.get(orbital.name);
+    if (!manifest) {
+      rebuilt.push(orbital);
+      continue;
+    }
+    rebuilt.push(applyParamsToOrb(orb, orbital.name, manifest, params));
+  }
+  return { ...orb, orbitals: rebuilt };
+}
+
+export { applyParamsToOrb, applyParamsToWholeOrb, extractManifest, mergeCallSiteConfigOverrides, rebindInlineTraitEntity, rewriteEntityInInlineTrait, validateOrbitalFactoryParams };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map