@almadar/core 10.29.0 → 10.31.0

package/dist/factory/index.d.ts

@@ -1,7 +1,8 @@
-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-CGC5A1-T.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-CGC5A1-T.js';
-import { a as EntityPersistence, E as EntityField } from '../pattern-types-JZordBZv.js';
-import { a as TraitReference } from '../trait-B_CzfDSi.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-DSfz2mr5.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-DSfz2mr5.js';
+import { a as EntityPersistence, E as EntityField } from '../pattern-types-VDIr2TkX.js';
+export { J as JsonValue } from '../pattern-types-VDIr2TkX.js';
+import { a as TraitReference } from '../trait-DE6VU4Cd.js';
 import 'zod';
 import '../expression-CB9R3KWk.js';
 

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

@@ -1,6 +1,6 @@
-import { O as OrbitalSchema, M as MakeTraitRefOpts, a as OrbitalDefinition } from '../builders-DcBjE_Uw.js';
-import { C as CallSiteConfig, b as CallSiteConfigEntry, c as Trait } from '../trait-B_CzfDSi.js';
-import { E as EntityField, a as EntityPersistence } from '../pattern-types-JZordBZv.js';
+import { O as OrbitalSchema, M as MakeTraitRefOpts, a as OrbitalDefinition } from '../builders-DDcCVboe.js';
+import { C as CallSiteConfig, b as CallSiteConfigEntry, c as Trait } from '../trait-DE6VU4Cd.js';
+import { E as EntityField, a as EntityPersistence } from '../pattern-types-VDIr2TkX.js';
 import 'zod';
 import '../expression-CB9R3KWk.js';
 
@@ -149,21 +149,66 @@ declare function rewriteEntityInInlineTrait(trait: Trait, oldName: string, newNa
  */
 declare function mergeCallSiteConfigOverrides(base: CallSiteConfig, overrides: CallSiteConfig): Record<string, CallSiteConfigEntry>;
 /**
- * Rewrite every reference to a renamed trait so a
- * `traitOverrides.<T>.name` override keeps the orbital internally
- * consistent. A rename changes ONLY the trait's local name; without this
- * pass the factory output still carries the canonical name in:
- *   - `pages[].traits[].ref` (→ ORB_P_INVALID_TRAIT_REF: "referenced on
- *     page does not exist" — the exact demotion storm the dashboard
- *     param-fill hit when the LLM renamed its chart traits), and
- *   - `@trait.<canonical>` tokens inside sibling traits' config (layout
- *     tile slots like `tile1Trait: "@trait.DefaultRevenueChart"`).
- *
- * Single canonical implementation shared by `applyParamsToOrb` (runtime
- * factory overlay) and every generated factory body (via the packages'
- * `factory-runtime` re-export shims). Pure — returns a new definition.
+ * 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`.
  */
-declare function applyTraitRenames(orbital: OrbitalDefinition, renames: ReadonlyMap<string, string>): OrbitalDefinition;
+at: string): OrbitalSchema;
 /**
  * The overlay. Resolves the effective entity name + collection, calls
  * `makeOrbitalWithUses` with the rewritten data, then applies the params'
@@ -187,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, applyTraitRenames, 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,95 @@
 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)
+});
+var JsonValueSchema = z.lazy(
+  () => z.union([z.string(), z.number(), z.boolean(), z.null(), z.array(JsonValueSchema), z.record(JsonValueSchema)])
+);
+
+// src/types/field.ts
 z.enum([
   "string",
   "number",
@@ -25,6 +114,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 +125,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
@@ -62,7 +153,7 @@ var EntityFieldSchema = z.lazy(() => {
   const baseFieldShape = {
     name: z.string().min(1, "Field name is required").optional(),
     required: z.boolean().optional(),
-    default: z.unknown().optional(),
+    default: JsonValueSchema.optional(),
     format: FieldFormatSchema.optional(),
     min: z.number().optional(),
     max: z.number().optional(),
@@ -329,6 +420,7 @@ var PayloadFieldSchema = z.object({
 });
 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(),
@@ -346,6 +438,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()
@@ -382,6 +475,7 @@ var ConfigFieldItemsDeclarationSchema = z.lazy(
 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(),
@@ -425,7 +519,7 @@ var TraitEntityFieldSchema = z.object({
     "enum"
   ]),
   required: z.boolean().optional(),
-  default: z.unknown().optional(),
+  default: TraitConfigValueSchema.optional(),
   values: z.array(z.string()).optional(),
   items: ConfigFieldItemsDeclarationSchema.optional(),
   properties: z.lazy(() => z.record(TraitEntityFieldSchema)).optional()
@@ -447,9 +541,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({
@@ -484,6 +580,7 @@ var TraitEventContractSchema = z.object({
     /^([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(),
@@ -492,16 +589,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(),
@@ -517,14 +622,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")
@@ -543,12 +654,11 @@ z.object({
   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[]`.
+  // names (the transition triggers AFTER renames); values are SExpr
+  // effect tuples.
   effects: z.record(
     z.string().min(1, "effects override key (event name) must be non-empty"),
-    z.array(z.unknown())
+    z.array(SExprSchema)
   ).optional()
 }).refine(
   (ref2) => {
@@ -574,6 +684,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(),
@@ -585,6 +696,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(),
@@ -627,10 +741,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"),
@@ -638,6 +755,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(),
@@ -1153,11 +1271,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,
@@ -1193,6 +1314,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(),
@@ -1253,7 +1375,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) => {
@@ -1370,6 +1497,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;
@@ -1656,32 +1784,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) {
@@ -1699,85 +1812,81 @@ function mergeCallSiteConfigOverrides(base, overrides) {
   }
   return next;
 }
-function applyTraitRenames(orbital, renames) {
-  if (renames.size === 0) return orbital;
-  const TRAIT_TOKEN = "@trait.";
-  const renameToken = (v) => {
-    if (!v.startsWith(TRAIT_TOKEN)) return v;
-    const renamed = renames.get(v.slice(TRAIT_TOKEN.length));
-    return renamed !== void 0 ? `${TRAIT_TOKEN}${renamed}` : v;
-  };
-  const rewriteValue = (v) => {
-    if (typeof v === "string") return renameToken(v);
-    if (Array.isArray(v)) return v.map(rewriteValue);
-    if (v !== null && typeof v === "object") {
-      const out = {};
-      for (const [k, x] of Object.entries(v)) out[k] = rewriteValue(x);
-      return out;
-    }
-    return v;
+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 rewriteEntry = (e) => {
-    if (isCallSiteConfigDeclaration(e)) {
-      return e.default !== void 0 ? { ...e, default: rewriteValue(e.default) } : e;
+  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 rewriteValue(e);
-  };
-  const rewriteConfig = (config) => {
-    const out = {};
-    for (const [k, e] of Object.entries(config)) out[k] = rewriteEntry(e);
-    return out;
-  };
-  const rewriteStateMachine = (sm) => JSON.parse(
-    JSON.stringify(sm),
-    (_k, v) => typeof v === "string" ? renameToken(v) : v
-  );
-  const traits = (orbital.traits ?? []).map((t) => {
-    if (typeof t !== "object" || t === null) return t;
-    if ("ref" in t) {
-      return t.config !== void 0 ? { ...t, config: rewriteConfig(t.config) } : t;
+  }
+  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 withConfig = t.config !== void 0 ? { ...t, config: rewriteConfig(t.config) } : t;
-    return withConfig.stateMachine !== void 0 ? { ...withConfig, stateMachine: rewriteStateMachine(withConfig.stateMachine) } : withConfig;
+    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 } : {}
+    };
   });
-  const renamePageTrait = (entry) => {
-    if (typeof entry === "string") return renames.get(entry) ?? entry;
-    if ("ref" in entry && typeof entry.ref === "string") {
-      const renamed = renames.get(entry.ref);
-      return renamed !== void 0 ? { ...entry, ref: renamed } : entry;
+  let ledger = schema.ledger;
+  if (ledger !== void 0) {
+    for (const id of renamedEntityIds) {
+      ledger = ledgerRename(ledger, id, rename.to, at);
     }
-    return entry;
-  };
-  const pages = (orbital.pages ?? []).map((p) => {
-    if (typeof p !== "object" || p === null) return p;
-    if (!Array.isArray(p.traits)) return p;
-    return { ...p, traits: p.traits.map(renamePageTrait) };
-  });
-  return { ...orbital, traits, pages };
+  }
+  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)
   });
-  const traitRenames = /* @__PURE__ */ new Map();
   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;
-      if (override.name !== void 0 && override.name !== t.name) {
-        traitRenames.set(t.name, override.name);
-      }
       const merged = { ...t };
       if (override.config !== void 0) {
         merged.config = mergeCallSiteConfigOverrides(t.config ?? {}, override.config);
@@ -1798,7 +1907,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;
@@ -1810,7 +1918,7 @@ function applyParamsToOrb(orb, orbitalName, _manifest, params) {
       return { ...p, path: params.pagePath };
     });
   }
-  return applyTraitRenames(built, traitRenames);
+  return built;
 }
 
 // src/factory-runtime/apply-params-to-whole-orb.ts
@@ -1831,6 +1939,6 @@ function applyParamsToWholeOrb(orb, manifests, params) {
   return { ...orb, orbitals: rebuilt };
 }
 
-export { applyParamsToOrb, applyParamsToWholeOrb, applyTraitRenames, extractManifest, mergeCallSiteConfigOverrides, rebindInlineTraitEntity, rewriteEntityInInlineTrait, validateOrbitalFactoryParams };
+export { applyDeclarationEntityRename, applyDeclarationTraitRenames, applyParamsToOrb, applyParamsToWholeOrb, extractManifest, mergeCallSiteConfigOverrides, rebindInlineTraitEntity, rewriteEntityInInlineTrait, validateOrbitalFactoryParams };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map