@almadar/core 10.28.0 → 10.30.0

package/dist/{expression-C6X4A8L7.d.ts → expression-CB9R3KWk.d.ts}

@@ -129,8 +129,11 @@ interface ParsedBinding {
  * `user` is the authenticated user / agent context (see binding.ts) and is
  * read-only in guards/effects/ticks — atoms reference `@user.id` and
  * `@user.role` for ownership / role-based gating.
+ * `callsitePayload` is the call-site-captured event payload emitted by the
+ * compiler's inline-trait hoisting; the runtime BindingResolver resolves it
+ * at the composing effect.
  */
-declare const CORE_BINDINGS: readonly ["entity", "payload", "state", "now", "config", "computed", "trait", "user"];
+declare const CORE_BINDINGS: readonly ["entity", "payload", "state", "now", "config", "computed", "trait", "user", "callsitePayload"];
 type CoreBinding = (typeof CORE_BINDINGS)[number];
 /**
  * Parses a binding reference into its components.

package/dist/factory/index.d.ts

@@ -1,9 +1,10 @@
-import { h as FactoryParamValue, c as FactoryConfigTier, b as FactoryConfigParam, F as FactoryCallSite, j as FactorySignature, R as RuleOverlay, r as RuleOverlayEntry, q as PresentationOverlay, s as TraitOverlay } from '../types-DFn3sWpV.js';
-export { a as FactoryCallSiteParams, d as FactoryEntitySignature, e as FactoryEventSignature, f as FactoryExposure, g as FactoryPageSignature, i as FactoryProvenance, k as FactorySignatureCatalog, l as FactorySignatureEntityField, m as FactoryTraitSignature, o as JsonSchema, p as JsonSchemaType, J as JsonValue, O as OwnershipOverlayEntry, P as PresentationNavItem, S as SchemaFieldType, t as TraitOverlayEntry, u as TraitOverlayListener } from '../types-DFn3sWpV.js';
-import { a as EntityPersistence, E as EntityField } from '../pattern-types-BeQXwgpZ.js';
-import { a as TraitReference } from '../trait-DZkS625T.js';
+import { h as FactoryParamValue, c as FactoryConfigTier, b as FactoryConfigParam, F as FactoryCallSite, j as FactorySignature, R as RuleOverlay, p as RuleOverlayEntry, o as PresentationOverlay, T as TraitOverlay } from '../types-yW22YNNt.js';
+export { a as FactoryCallSiteParams, d as FactoryEntitySignature, e as FactoryEventSignature, f as FactoryExposure, g as FactoryPageSignature, i as FactoryProvenance, k as FactorySignatureCatalog, l as FactorySignatureEntityField, m as FactoryTraitSignature, J as JsonSchema, n as JsonSchemaType, O as OwnershipOverlayEntry, P as PresentationNavItem, S as SchemaFieldType, q as TraitOverlayEntry, r as TraitOverlayListener } from '../types-yW22YNNt.js';
+import { a as EntityPersistence, E as EntityField } from '../pattern-types-CLcOXOmW.js';
+import { a as TraitReference } from '../trait-CwWjkU-1.js';
+export { J as JsonValue } from '../json-DOTchoRS.js';
 import 'zod';
-import '../expression-C6X4A8L7.js';
+import '../expression-CB9R3KWk.js';
 
 /**
  * Typed questionnaire surface — shapes the studio renders + answers.

package/dist/factory-runtime/index.d.ts

@@ -1,8 +1,8 @@
-import { O as OrbitalSchema, M as MakeTraitRefOpts, a as OrbitalDefinition } from '../builders-BN3WLFYM.js';
-import { C as CallSiteConfig, b as CallSiteConfigEntry, c as Trait } from '../trait-DZkS625T.js';
-import { E as EntityField, a as EntityPersistence } from '../pattern-types-BeQXwgpZ.js';
+import { O as OrbitalSchema, M as MakeTraitRefOpts, a as OrbitalDefinition } from '../builders-C458pIMW.js';
+import { C as CallSiteConfig, b as CallSiteConfigEntry, c as Trait } from '../trait-CwWjkU-1.js';
+import { E as EntityField, a as EntityPersistence } from '../pattern-types-CLcOXOmW.js';
 import 'zod';
-import '../expression-C6X4A8L7.js';
+import '../expression-CB9R3KWk.js';
 
 /**
  * Orbital factory manifest types — shared across all packages.
@@ -148,6 +148,67 @@ declare function rewriteEntityInInlineTrait(trait: Trait, oldName: string, newNa
  *   - generated `mergeExtraTraitWithOverlay` in dispatch.ts
  */
 declare function mergeCallSiteConfigOverrides(base: CallSiteConfig, overrides: CallSiteConfig): Record<string, CallSiteConfigEntry>;
+/**
+ * Apply `traitOverrides.<T>.name` renames to trait DECLARATIONS only,
+ * AFTER the schema has been stamped (V4-W4 stamp-before-rename).
+ *
+ * A trait rename is a pure display-name change: it renames the declaration
+ * (`traits[].name` for inline traits, the ref object's local `name` for
+ * reference traits) and nothing else. Every REFERENCE to the trait —
+ * `pages[].traits[].ref`, `@trait.<canonical>` tokens in sibling config /
+ * stateMachine effect trees — is left carrying its canonical name AND its
+ * stamped id (page ref `refId`, the referring trait's `traitEmbedIds`
+ * side-map). Readers resolve those references by stable id onto the renamed
+ * declaration, so no token/page-ref rewrite is needed (this replaced the
+ * deleted `applyTraitRenames`).
+ *
+ * The keys are canonical names because stamping ran while the declaration
+ * still carried its canonical name (the factory no longer renames — see
+ * `applyParamsToOrb`), so `trait.name === canonicalKey` at this point.
+ *
+ * Pure — returns a new schema. Applied per orbital; the same override key
+ * renames the matching declaration in every orbital that owns it (matches
+ * the former per-orbital `applyParamsToOrb` semantics).
+ */
+declare function applyDeclarationTraitRenames(schema: OrbitalSchema, renames: ReadonlyMap<string, string>, 
+/**
+ * Rename timestamp (ISO string) for the ledger `renames[]` audit row. Threaded
+ * from the persistence layer (which owns the clock). The stamp keyed each inline
+ * trait's ledger `curName` to its canonical name; without this update the renamed
+ * declaration disagrees with `curName` → `ORB_ID_NAME_MISMATCH` on the page ref.
+ */
+at: string): OrbitalSchema;
+/** A single entity display rename: `from` (canonical name at stamp) → `to`. */
+interface EntityDeclarationRename {
+    readonly from: string;
+    readonly to: string;
+}
+/**
+ * Apply an entity rename to DECLARATIONS only, AFTER the schema has been
+ * stamped (V4-W4 stamp-before-rename). The entity, its `@entity.<from>` body
+ * tokens, and every trait/page `linkedEntity` were all emitted CANONICAL by
+ * the factory, so stamping keyed `entityRefIds`/`linkedEntityId` by `from`.
+ *
+ * This renames only the visible declaration surface — `entity.name` and every
+ * trait/page `linkedEntity` whose value is `from` — leaving the `@entity.<from>`
+ * body tokens and every stamped id untouched. Readers resolve those tokens by
+ * `entityRefIds` id and resolve `linkedEntity` by `linkedEntityId`, so the
+ * rename lands on the right declaration without any body rewrite (this is what
+ * lets the factory stop calling `rebindInlineTraitEntity`). Collection is not
+ * renamed here — its effective value was already baked at build time.
+ *
+ * Pure — returns a new schema. Applied to every orbital whose primary entity
+ * is named `from` (mirrors the former per-orbital `applyParamsToOrb` scope for
+ * a single-orbital write).
+ */
+declare function applyDeclarationEntityRename(schema: OrbitalSchema, rename: EntityDeclarationRename, 
+/**
+ * Rename timestamp (ISO string) for the ledger `renames[]` audit row. Threaded
+ * from the persistence layer (which owns the clock). The stamp keyed the ledger
+ * `curName` to the canonical entity name; without this update the renamed
+ * declaration disagrees with `curName` → `ORB_ID_NAME_MISMATCH`.
+ */
+at: string): OrbitalSchema;
 /**
  * The overlay. Resolves the effective entity name + collection, calls
  * `makeOrbitalWithUses` with the rewritten data, then applies the params'
@@ -171,4 +232,4 @@ declare function applyParamsToOrb(orb: OrbitalSchema, orbitalName: string, _mani
 
 declare function applyParamsToWholeOrb(orb: OrbitalSchema, manifests: readonly OrbitalParamsManifest[], params: OrbitalFactoryParams): OrbitalSchema;
 
-export { type OrbitalFactoryParams, type OrbitalParamsManifest, type OrbitalTraitOverride, type ParamFieldDescriptor, type ParamValidationError, type ParamValidationResult, applyParamsToOrb, applyParamsToWholeOrb, extractManifest, mergeCallSiteConfigOverrides, rebindInlineTraitEntity, rewriteEntityInInlineTrait, validateOrbitalFactoryParams };
+export { type EntityDeclarationRename, type OrbitalFactoryParams, type OrbitalParamsManifest, type OrbitalTraitOverride, type ParamFieldDescriptor, type ParamValidationError, type ParamValidationResult, applyDeclarationEntityRename, applyDeclarationTraitRenames, applyParamsToOrb, applyParamsToWholeOrb, extractManifest, mergeCallSiteConfigOverrides, rebindInlineTraitEntity, rewriteEntityInInlineTrait, validateOrbitalFactoryParams };

package/dist/factory-runtime/index.js

@@ -1,6 +1,90 @@
 import { z } from 'zod';
 
 // src/types/orbital.ts
+var ID_PREFIXES = {
+  orbital: "orb_",
+  entity: "ent_",
+  trait: "trt_",
+  event: "evt_",
+  page: "pag_",
+  service: "svc_",
+  theme: "thm_",
+  palette: "pal_"
+};
+function brand(value) {
+  return value;
+}
+function makeIdKind(kind) {
+  const prefix = ID_PREFIXES[kind];
+  const is = (value) => value.startsWith(prefix) && value.length > prefix.length;
+  const as = (value) => {
+    if (!is(value)) {
+      throw new Error(
+        `Expected ${kind} id (prefix "${prefix}"), got: ${JSON.stringify(value)}`
+      );
+    }
+    return brand(value);
+  };
+  return { prefix, is, as };
+}
+var orbitalKind = makeIdKind("orbital");
+var entityKind = makeIdKind("entity");
+var traitKind = makeIdKind("trait");
+var eventKind = makeIdKind("event");
+var pageKind = makeIdKind("page");
+var serviceKind = makeIdKind("service");
+var themeKind = makeIdKind("theme");
+var paletteKind = makeIdKind("palette");
+var isOrbitalId = orbitalKind.is;
+var isEntityId = entityKind.is;
+var isTraitId = traitKind.is;
+var isEventId = eventKind.is;
+var isPageId = pageKind.is;
+var isServiceId = serviceKind.is;
+var isThemeId = themeKind.is;
+var isPaletteEntryId = paletteKind.is;
+function ledgerRename(ledger, id, to, at) {
+  const entry = ledger.entries[id];
+  if (entry === void 0) return ledger;
+  const updated = {
+    ...entry,
+    curName: to,
+    renames: [...entry.renames, { from: entry.curName, to, at }]
+  };
+  return { ...ledger, entries: { ...ledger.entries, [id]: updated } };
+}
+var OrbitalIdSchema = z.string().refine(isOrbitalId, { message: `Expected an orbital id (prefix "${ID_PREFIXES.orbital}")` });
+var EntityIdSchema = z.string().refine(isEntityId, { message: `Expected an entity id (prefix "${ID_PREFIXES.entity}")` });
+var TraitIdSchema = z.string().refine(isTraitId, { message: `Expected a trait id (prefix "${ID_PREFIXES.trait}")` });
+var EventIdSchema = z.string().refine(isEventId, { message: `Expected an event id (prefix "${ID_PREFIXES.event}")` });
+var PageIdSchema = z.string().refine(isPageId, { message: `Expected a page id (prefix "${ID_PREFIXES.page}")` });
+z.string().refine(isServiceId, { message: `Expected a service id (prefix "${ID_PREFIXES.service}")` });
+z.string().refine(isThemeId, { message: `Expected a theme id (prefix "${ID_PREFIXES.theme}")` });
+z.string().refine(isPaletteEntryId, { message: `Expected a palette-entry id (prefix "${ID_PREFIXES.palette}")` });
+var LedgerKindSchema = z.enum([
+  "orbital",
+  "entity",
+  "trait",
+  "event",
+  "page",
+  "service",
+  "theme"
+]);
+var LedgerEntrySchema = z.object({
+  id: z.string(),
+  kind: LedgerKindSchema,
+  bakedName: z.string(),
+  curName: z.string(),
+  renames: z.array(
+    z.object({ from: z.string(), to: z.string(), at: z.string() })
+  ),
+  owner: z.enum(["std", "io", "workspace"]),
+  parent: TraitIdSchema.optional()
+});
+var IdentityLedgerSchema = z.object({
+  schemaVersion: z.literal(1),
+  entries: z.record(LedgerEntrySchema)
+});
 z.enum([
   "string",
   "number",
@@ -25,6 +109,7 @@ var RelationCardinalitySchema = z.enum([
 ]);
 var RelationConfigSchema = z.object({
   entity: z.string().min(1, "Target entity is required"),
+  entityId: EntityIdSchema.optional(),
   field: z.string().optional(),
   cardinality: RelationCardinalitySchema.optional(),
   onDelete: z.enum(["cascade", "nullify", "restrict"]).optional(),
@@ -35,6 +120,7 @@ var RelationConfigSchema = z.object({
 }).transform((data) => {
   const normalized = {
     entity: data.entity || data.target || "",
+    entityId: data.entityId,
     cardinality: data.cardinality || data.type,
     field: data.field,
     onDelete: data.onDelete
@@ -324,10 +410,12 @@ var StateSchema = z.object({
 var PayloadFieldSchema = z.object({
   name: z.string().min(1),
   type: z.string().min(1),
-  required: z.boolean().optional()
+  required: z.boolean().optional(),
+  properties: z.lazy(() => z.array(PayloadFieldSchema)).optional()
 });
 var EventSchema = z.object({
   key: z.string().min(1, "Event key is required"),
+  id: EventIdSchema.optional(),
   name: z.string().min(1, "Event name is required"),
   description: z.string().optional(),
   synonyms: z.string().optional(),
@@ -345,6 +433,7 @@ 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"),
+  eventId: EventIdSchema.optional(),
   guard: ExpressionSchema.nullish(),
   effects: z.array(EffectSchema).optional(),
   description: z.string().nullish()
@@ -371,14 +460,25 @@ 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 ConfigFieldItemsDeclarationSchema = z.lazy(
+  () => z.object({
+    type: z.string().optional(),
+    properties: z.record(TraitEntityFieldSchema).optional(),
+    items: ConfigFieldItemsDeclarationSchema.optional()
+  })
+);
 var ConfigFieldDeclarationSchema = z.object({
   type: z.string(),
   default: TraitConfigValueSchema.optional(),
+  refId: z.string().optional(),
+  required: z.boolean().optional(),
   label: z.string().optional(),
   description: z.string().optional(),
   tier: z.string().optional(),
   values: z.array(z.string()).optional(),
-  synonyms: z.string().optional()
+  synonyms: z.string().optional(),
+  items: ConfigFieldItemsDeclarationSchema.optional(),
+  properties: z.lazy(() => z.record(TraitEntityFieldSchema)).optional()
 });
 var DeclaredTraitConfigSchema = z.record(
   ConfigFieldDeclarationSchema
@@ -415,7 +515,9 @@ var TraitEntityFieldSchema = z.object({
   ]),
   required: z.boolean().optional(),
   default: z.unknown().optional(),
-  values: z.array(z.string()).optional()
+  values: z.array(z.string()).optional(),
+  items: ConfigFieldItemsDeclarationSchema.optional(),
+  properties: z.lazy(() => z.record(TraitEntityFieldSchema)).optional()
 });
 var TraitDataEntitySchema = z.object({
   name: z.string().min(1),
@@ -434,9 +536,11 @@ var TraitTickSchema = z.object({
   interval: z.union([z.literal("frame"), z.number().positive()]),
   appliesTo: z.array(z.string()).optional(),
   pages: z.array(z.string()).optional(),
+  pageIds: z.array(PageIdSchema).optional(),
   guard: ExpressionSchema.optional(),
   effects: z.array(EffectSchema).min(1),
-  emits: z.array(z.string()).optional()
+  emits: z.array(z.string()).optional(),
+  emitIds: z.array(EventIdSchema).optional()
 });
 var EventScopeSchema = z.enum(["internal", "external"]);
 var EventPayloadFieldSchema = z.object({
@@ -454,7 +558,8 @@ var EventPayloadFieldSchema = z.object({
   type: z.string().min(1),
   required: z.boolean().optional(),
   description: z.string().optional(),
-  entityType: z.string().optional()
+  entityType: z.string().optional(),
+  properties: z.lazy(() => z.array(EventPayloadFieldSchema)).optional()
 });
 var TraitEventContractSchema = z.object({
   /**
@@ -462,12 +567,15 @@ var TraitEventContractSchema = z.object({
    * 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>`).
+   * `type X = Event<T>`). A pre-resolution `@config.<knob>` reference
+   * (Option B) is also legal — inline/resolve substitutes it with the
+   * knob's effective literal before codegen/runtime consume it.
    */
   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"
+    /^([A-Za-z][A-Za-z0-9_]*|@config\.[A-Za-z_][A-Za-z0-9_]*)$/,
+    "Event name must start with a letter and contain only letters, digits, and underscores, or be a `@config.<knob>` reference"
   ),
+  eventId: EventIdSchema.optional(),
   description: z.string().optional(),
   synonyms: z.string().optional(),
   tier: z.string().optional(),
@@ -476,16 +584,24 @@ var TraitEventContractSchema = z.object({
 });
 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("trait"),
+    trait: z.string().min(1),
+    traitId: TraitIdSchema.optional()
+  }),
   z.object({
     kind: z.literal("orbital"),
     orbital: z.string().min(1),
-    trait: z.string().min(1)
+    trait: z.string().min(1),
+    orbitalId: OrbitalIdSchema.optional(),
+    traitId: TraitIdSchema.optional()
   })
 ]);
 var TraitEventListenerSchema = z.object({
   event: z.string().min(1),
+  eventId: EventIdSchema.optional(),
   triggers: z.string().min(1),
+  triggersId: EventIdSchema.optional(),
   description: z.string().optional(),
   synonyms: z.string().optional(),
   tier: z.string().optional(),
@@ -501,14 +617,20 @@ var RequiredFieldSchema = z.object({
 });
 z.object({
   ref: z.string().min(1),
+  refId: TraitIdSchema.optional(),
+  // V4 local declaration id (see the interface doc) — declared so the
+  // strip-mode zod gate carries it through instead of dropping it.
+  id: TraitIdSchema.optional(),
   // Phase 1.2: optional registry path disambiguator, pairs with `ref`.
   from: z.string().optional(),
   linkedEntity: z.string().optional(),
+  linkedEntityId: EntityIdSchema.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(),
+  eventIds: z.record(z.string().min(1), EventIdSchema).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")
@@ -558,6 +680,7 @@ var SourceBehaviorMetadataSchema = z.object({
   originalName: z.string().min(1)
 });
 var TraitSchema = z.object({
+  id: TraitIdSchema.optional(),
   name: z.string().min(1),
   description: z.string().optional(),
   description_visual_prompt: z.string().optional(),
@@ -569,6 +692,9 @@ var TraitSchema = z.object({
   capabilities: z.array(z.string()).optional(),
   scope: TraitScopeSchema,
   linkedEntity: z.string().optional(),
+  linkedEntityId: EntityIdSchema.optional(),
+  entityRefIds: z.record(z.string().min(1), EntityIdSchema).optional(),
+  traitEmbedIds: z.record(z.string().min(1), TraitIdSchema).optional(),
   requiredFields: z.array(RequiredFieldSchema).optional(),
   dataEntities: z.array(TraitDataEntitySchema).optional(),
   stateMachine: StateMachineSchema.optional(),
@@ -611,10 +737,13 @@ var ViewTypeSchema = z.enum([
 ]);
 var PageTraitRefSchema = z.object({
   ref: z.string().min(1, "Trait ref is required"),
+  refId: TraitIdSchema.optional(),
   linkedEntity: z.string().optional(),
+  linkedEntityId: EntityIdSchema.optional(),
   config: TraitConfigSchema.optional()
 });
 z.object({
+  id: PageIdSchema.optional(),
   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"),
@@ -622,6 +751,7 @@ z.object({
   title: z.string().optional()
 }).strict();
 var OrbitalPageSchema = z.object({
+  id: PageIdSchema.optional(),
   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(),
@@ -1137,11 +1267,14 @@ var PageRefStringSchema = z.string().regex(
 );
 var PageRefObjectSchema = z.object({
   ref: PageRefStringSchema,
+  refId: PageIdSchema.optional(),
   // 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()
+  linkedEntityId: EntityIdSchema.optional(),
+  traits: z.array(TraitRefSchema).optional(),
+  traitRefIds: z.array(TraitIdSchema).optional()
 });
 var PageRefSchema = z.union([
   PageSchema,
@@ -1177,6 +1310,7 @@ var ComputedEventListenerSchema = z.object({
   payloadMapping: z.record(z.string()).optional()
 });
 var OrbitalDefinitionSchema = z.object({
+  id: OrbitalIdSchema.optional(),
   name: z.string().min(1, "Orbital name is required"),
   description: z.string().optional(),
   visual_prompt: z.string().optional(),
@@ -1237,7 +1371,12 @@ z.object({
   orbitals: z.array(OrbitalSchema).min(1, "At least one orbital is required"),
   services: z.array(ServiceDefinitionSchema).optional(),
   config: OrbitalConfigSchema.optional(),
-  _metadata: SchemaMetadataSchema.optional()
+  _metadata: SchemaMetadataSchema.optional(),
+  // V4 identity — optional/dual-carry until the Phase-7 flip. Present on
+  // id-carrying `.orb` files so `parseOrbitalSchema` preserves them instead
+  // of stripping unknown keys.
+  schemaVersion: z.number().optional(),
+  ledger: IdentityLedgerSchema.optional()
 });
 z.string().refine(
   (val) => {
@@ -1354,6 +1493,7 @@ function makeTraitRef(opts) {
   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.linkedEntityId !== void 0) ref2.linkedEntityId = opts.linkedEntityId;
   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;
@@ -1640,32 +1780,17 @@ function rewriteEntityInInlineTrait(trait, oldName, newName) {
   }
   return next;
 }
-function rebuildTraits(ctx, effectiveEntityName, traits) {
+function rebuildTraits(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);
+    if (!isTraitReferenceObject(t)) return t;
+    return makeTraitRef({ ...t });
   });
 }
-function rebuildPages(ctx, effectiveEntityName, pages) {
+function rebuildPages(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);
+    if (!isPageRefObject(p)) return p;
+    return makePageRef({ ...p });
   });
 }
 function mergeCallSiteConfigOverrides(base, overrides) {
@@ -1683,19 +1808,75 @@ function mergeCallSiteConfigOverrides(base, overrides) {
   }
   return next;
 }
+function applyDeclarationTraitRenames(schema, renames, at) {
+  if (renames.size === 0) return schema;
+  const renamedTraitIds = [];
+  const renameDeclaration = (t) => {
+    if (typeof t !== "object" || t === null) return t;
+    const named = t;
+    if (typeof named.name !== "string") return t;
+    const renamed = renames.get(named.name);
+    if (renamed === void 0) return t;
+    const id = t.id;
+    if (typeof id === "string") renamedTraitIds.push({ id, to: renamed });
+    return { ...t, name: renamed };
+  };
+  const orbitals = schema.orbitals.map((orbital) => {
+    if (!("traits" in orbital) || !Array.isArray(orbital.traits)) return orbital;
+    return { ...orbital, traits: orbital.traits.map(renameDeclaration) };
+  });
+  let ledger = schema.ledger;
+  if (ledger !== void 0) {
+    for (const { id, to } of renamedTraitIds) {
+      ledger = ledgerRename(ledger, id, to, at);
+    }
+  }
+  return { ...schema, orbitals, ...ledger !== schema.ledger ? { ledger } : {} };
+}
+function applyDeclarationEntityRename(schema, rename, at) {
+  if (rename.from === rename.to) return schema;
+  const linkedEntityIsFrom = (shape) => shape.linkedEntity === rename.from;
+  const renamedEntityIds = [];
+  const orbitals = schema.orbitals.map((orbital) => {
+    const entity = orbital.entity;
+    if (typeof entity !== "object" || entity === null || entity.name !== rename.from) {
+      return orbital;
+    }
+    const entityId = entity.id;
+    if (typeof entityId === "string") renamedEntityIds.push(entityId);
+    const traits = orbital.traits.map(
+      (t) => typeof t === "object" && t !== null && linkedEntityIsFrom(t) ? { ...t, linkedEntity: rename.to } : t
+    );
+    const pages = orbital.pages?.map(
+      (p) => typeof p === "object" && p !== null && linkedEntityIsFrom(p) ? { ...p, linkedEntity: rename.to } : p
+    );
+    return {
+      ...orbital,
+      entity: { ...entity, name: rename.to },
+      traits,
+      ...pages !== void 0 ? { pages } : {}
+    };
+  });
+  let ledger = schema.ledger;
+  if (ledger !== void 0) {
+    for (const id of renamedEntityIds) {
+      ledger = ledgerRename(ledger, id, rename.to, at);
+    }
+  }
+  return { ...schema, orbitals, ...ledger !== schema.ledger ? { ledger } : {} };
+}
 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 ctx = { 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)
+    entity: buildEntity(ctx, canonicalEntityName, effectiveCollection, params),
+    traits: rebuildTraits(orbital.traits),
+    pages: rebuildPages(orbital.pages)
   });
   if (built.traits && params.traitOverrides !== void 0) {
     built.traits = built.traits.map((t) => {
@@ -1722,7 +1903,6 @@ function applyParamsToOrb(orb, orbitalName, _manifest, params) {
         }
         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;
@@ -1755,6 +1935,6 @@ function applyParamsToWholeOrb(orb, manifests, params) {
   return { ...orb, orbitals: rebuilt };
 }
 
-export { applyParamsToOrb, applyParamsToWholeOrb, extractManifest, mergeCallSiteConfigOverrides, rebindInlineTraitEntity, rewriteEntityInInlineTrait, validateOrbitalFactoryParams };
+export { applyDeclarationEntityRename, applyDeclarationTraitRenames, applyParamsToOrb, applyParamsToWholeOrb, extractManifest, mergeCallSiteConfigOverrides, rebindInlineTraitEntity, rewriteEntityInInlineTrait, validateOrbitalFactoryParams };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map