@cadenza.io/service 2.19.1 → 2.20.1

package/dist/browser/index.mjs

@@ -79,14 +79,55 @@ var ROOT_METADATA_PASSTHROUGH_KEYS = [
   "__inquirySourceRoutineExecutionId"
 ];
 var DELEGATION_REQUEST_SNAPSHOT_KEY = "__delegationRequestContext";
+var DELEGATION_FAILURE_CONTEXT_KEYS = [
+  "__remoteRoutineName",
+  "__serviceName",
+  "__timeout",
+  "__localTaskName",
+  "__localTaskVersion",
+  "__localServiceName",
+  "__localRoutineExecId",
+  "__previousTaskExecutionId",
+  "__fetchId",
+  "fetchId",
+  "__routeKey",
+  "routeKey",
+  "__instance",
+  "__transportId",
+  "__transportOrigin",
+  "__transportProtocols",
+  "__transportProtocol",
+  "__retries",
+  "__triedInstances",
+  "__delegationRequestContext",
+  "__metadata",
+  "serviceName",
+  "serviceInstanceId",
+  "serviceTransportId",
+  "serviceOrigin",
+  "transportProtocols",
+  "transportProtocol"
+];
+function isPlainObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
 function cloneDelegationValue(value) {
+  if (value instanceof Date) {
+    return new Date(value.getTime());
+  }
   if (Array.isArray(value)) {
-    return value.map(
-      (item) => item && typeof item === "object" ? { ...item } : item
-    );
+    return value.map((item) => cloneDelegationValue(item));
   }
-  if (value && typeof value === "object") {
-    return { ...value };
+  if (isPlainObject(value)) {
+    const clone = {};
+    for (const [key, nestedValue] of Object.entries(value)) {
+      clone[key] = cloneDelegationValue(nestedValue);
+    }
+    return clone;
   }
   return value;
 }
@@ -122,9 +163,9 @@ function attachDelegationRequestSnapshot(input) {
 function restoreDelegationRequestSnapshot(input) {
   const context = input && typeof input === "object" ? { ...input } : {};
   const mutableContext = context;
-  const snapshotCandidate = mutableContext[DELEGATION_REQUEST_SNAPSHOT_KEY];
+  const snapshotCandidate = mutableContext[DELEGATION_REQUEST_SNAPSHOT_KEY] ?? (mutableContext.__metadata && typeof mutableContext.__metadata === "object" ? mutableContext.__metadata[DELEGATION_REQUEST_SNAPSHOT_KEY] : void 0);
   const snapshot = snapshotCandidate && typeof snapshotCandidate === "object" ? snapshotCandidate : null;
-  const looksLikeDelegationResult = mutableContext.__status !== void 0 || mutableContext.__success !== void 0 || mutableContext.rowCount !== void 0 || mutableContext.__nextNodes !== void 0 || mutableContext.__isDeputy === true;
+  const looksLikeDelegationResult = mutableContext.__status !== void 0 || mutableContext.__success !== void 0 || mutableContext.rowCount !== void 0 || mutableContext.__nextNodes !== void 0 || mutableContext.__isDeputy === true || mutableContext.errored === true || mutableContext.failed === true || mutableContext.timedOut === true || mutableContext.__error !== void 0 || mutableContext.error !== void 0 || mutableContext.__inquiryMeta !== void 0;
   if (!snapshot || !looksLikeDelegationResult) {
     return context;
   }
@@ -145,6 +186,26 @@ function stripDelegationRequestSnapshot(input) {
   delete context[DELEGATION_REQUEST_SNAPSHOT_KEY];
   return context;
 }
+function buildDelegationFailureContext(signalName, input, error) {
+  const source = input && typeof input === "object" ? { ...input } : {};
+  const slimContext = {};
+  for (const key of DELEGATION_FAILURE_CONTEXT_KEYS) {
+    if (source[key] !== void 0) {
+      slimContext[key] = cloneDelegationValue(source[key]);
+    }
+  }
+  if (slimContext[DELEGATION_REQUEST_SNAPSHOT_KEY] === void 0 && source.__metadata && typeof source.__metadata === "object" && source.__metadata[DELEGATION_REQUEST_SNAPSHOT_KEY] !== void 0) {
+    slimContext[DELEGATION_REQUEST_SNAPSHOT_KEY] = cloneDelegationValue(
+      source.__metadata[DELEGATION_REQUEST_SNAPSHOT_KEY]
+    );
+  }
+  return {
+    __signalName: signalName,
+    __error: error instanceof Error ? error.message : String(error ?? "Unknown error"),
+    errored: true,
+    ...slimContext
+  };
+}
 function stripTransportSelectionRoutingContext(input) {
   const context = stripLocalRoutinePersistenceHints(
     input && typeof input === "object" ? { ...input } : {}
@@ -364,6 +425,8 @@ var DeputyTask = class extends Task {
 
 // src/graph/definition/DatabaseTask.ts
 var ACTOR_SESSION_TRACE_ENABLED = process.env.CADENZA_ACTOR_SESSION_TRACE === "1" || process.env.CADENZA_ACTOR_SESSION_TRACE === "true";
+var actorSessionEmptyDelegationLogCount = 0;
+var ACTOR_SESSION_EMPTY_DELEGATION_LOG_LIMIT = 40;
 var INSTANCE_TRACE_ENABLED = process.env.CADENZA_INSTANCE_DEBUG === "1" || process.env.CADENZA_INSTANCE_DEBUG === "true";
 var EXECUTION_OBSERVABILITY_INSERT_ROUTINES = /* @__PURE__ */ new Set([
   "Insert execution_trace",
@@ -465,15 +528,16 @@ var DatabaseTask = class extends DeputyTask {
     }
     delete ctx.__metadata;
     const isResolverExecution = typeof ctx.__resolverRequestId === "string" && ctx.__resolverRequestId.length > 0;
-    const dynamicQueryData = isResolverExecution ? {} : ctx.__resolverQueryData && typeof ctx.__resolverQueryData === "object" ? ctx.__resolverQueryData : ctx.queryData ?? {};
+    const resolverQueryData = ctx.__resolverQueryData && typeof ctx.__resolverQueryData === "object" ? ctx.__resolverQueryData : null;
+    const dynamicQueryData = resolverQueryData ?? (ctx.queryData && typeof ctx.queryData === "object" ? ctx.queryData : {});
     delete ctx.queryData;
     const nextQueryData = {
       ...this.queryData,
-      data: {
-        ...ctx.data
-      },
       ...dynamicQueryData
     };
+    if (dynamicQueryData.data === void 0 && ctx.data !== void 0) {
+      nextQueryData.data = ctx.data && typeof ctx.data === "object" && !Array.isArray(ctx.data) ? { ...ctx.data } : ctx.data;
+    }
     const deputyContext = attachDelegationRequestSnapshot(
       stripDelegationRequestSnapshot(
         hoistDelegationMetadataFields({
@@ -533,6 +597,22 @@ var DatabaseTask = class extends DeputyTask {
         rootKeys: Object.keys(rawContext)
       });
     }
+    if (this.remoteRoutineName === "Insert actor_session_state" && deputyContext.data === void 0 && deputyContext.queryData === void 0 && actorSessionEmptyDelegationLogCount < ACTOR_SESSION_EMPTY_DELEGATION_LOG_LIMIT) {
+      actorSessionEmptyDelegationLogCount += 1;
+      console.warn("[CADENZA_ACTOR_SESSION_EMPTY_DELEGATION]", {
+        localServiceName: CadenzaService.serviceRegistry.serviceName,
+        localTaskName: this.name,
+        remoteRoutineName: this.remoteRoutineName,
+        hadSnapshotBeforeRestore: initialFullContext.__delegationRequestContext !== void 0 || initialFullContext.__metadata?.__delegationRequestContext !== void 0,
+        restoredRootKeys: Object.keys(rawContext),
+        deputyRootKeys: Object.keys(deputyContext),
+        signalName: rawContext.__signalName ?? rawContext.__metadata?.__signalName ?? null,
+        inquiryName: rawContext.__inquiryName ?? rawContext.__metadata?.__inquiryName ?? null,
+        sourceServiceName: rawContext.__localServiceName ?? rawContext.__metadata?.__localServiceName ?? null,
+        sourceRoutineName: rawContext.__routineName ?? rawContext.__metadata?.__routineName ?? null,
+        sourceTaskName: rawContext.__localTaskName ?? rawContext.__metadata?.__localTaskName ?? null
+      });
+    }
     return this.taskFunction(deputyContext, emit2, inquire, progressCallback);
   }
 };
@@ -572,14 +652,14 @@ var META_INTENT_PREFIX = "meta-";
 var META_RUNTIME_TRANSPORT_DIAGNOSTICS_INTENT = "meta-runtime-transport-diagnostics";
 var META_RUNTIME_STATUS_INTENT = "meta-runtime-status";
 var META_READINESS_INTENT = "meta-readiness";
-function isPlainObject(value) {
+function isPlainObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
 }
 function deepMergeDeterministic(left, right) {
   if (Array.isArray(left) && Array.isArray(right)) {
     return [...left, ...right];
   }
-  if (isPlainObject(left) && isPlainObject(right)) {
+  if (isPlainObject2(left) && isPlainObject2(right)) {
     const merged = { ...left };
     const keys = Array.from(/* @__PURE__ */ new Set([...Object.keys(left), ...Object.keys(right)])).sort();
     for (const key of keys) {
@@ -1401,6 +1481,7 @@ function normalizeServiceManifestSnapshot(input) {
     revision,
     manifestHash,
     publishedAt,
+    publicationLayer: record.publicationLayer === "routing_capability" || record.publicationLayer === "business_structural" || record.publicationLayer === "local_meta_structural" ? record.publicationLayer : "business_structural",
     tasks: normalizeArray(record.tasks),
     signals: normalizeArray(record.signals),
     intents: normalizeArray(record.intents),
@@ -1530,6 +1611,7 @@ function decomposeSignalName(signalName) {
 }
 
 // src/registry/serviceManifest.ts
+import CoreCadenza from "@cadenza.io/core";
 var ACTOR_TASK_METADATA = /* @__PURE__ */ Symbol.for("@cadenza.io/core/actor-task-meta");
 function getActorTaskRuntimeMetadata(taskFunction) {
   if (typeof taskFunction !== "function") {
@@ -1674,14 +1756,48 @@ function buildRoutineDefinition(routine, serviceName) {
   };
 }
 function shouldExportTask(task) {
-  return !task.isDeputy && !task.isEphemeral;
+  return task.register !== false && task.isHidden !== true && !task.isDeputy && !task.isEphemeral;
 }
 function shouldExportRoutine(routine) {
   return Boolean(String(routine?.name ?? "").trim());
 }
+function buildTaskKey(task) {
+  return `${task.service_name}|${task.name}|${task.version}`;
+}
+function buildActorKey(actor) {
+  return `${actor.service_name}|${actor.name}|${actor.version}`;
+}
+function buildRoutineKey(routine) {
+  return `${routine.service_name}|${routine.name}|${routine.version}`;
+}
+function listManifestTasks() {
+  const registryTasks = Array.from(CadenzaService.registry.tasks.values()).filter(
+    (task) => Boolean(task)
+  );
+  const cachedTasks = Array.from(
+    CoreCadenza.taskCache?.values?.() ?? []
+  ).filter((task) => Boolean(task));
+  return Array.from(
+    new Map(
+      [...registryTasks, ...cachedTasks].map((task) => [task.name, task])
+    ).values()
+  );
+}
+function isRoutingCriticalMetaSignal(_signal) {
+  return false;
+}
+function isRoutingCriticalMetaIntent(_intent) {
+  return false;
+}
 function buildServiceManifestSnapshot(params) {
-  const { serviceName, serviceInstanceId, revision, publishedAt } = params;
-  const tasks = Array.from(CadenzaService.registry.tasks.values()).filter((task) => Boolean(task)).filter(shouldExportTask);
+  const {
+    serviceName,
+    serviceInstanceId,
+    revision,
+    publishedAt,
+    publicationLayer = "business_structural"
+  } = params;
+  const tasks = listManifestTasks().filter(shouldExportTask);
   const routines = Array.from(CadenzaService.registry.routines.values()).filter((routine) => Boolean(routine)).filter(shouldExportRoutine);
   const actors = CadenzaService.getAllActors();
   const taskDefinitions = tasks.map((task) => buildTaskDefinition(task, serviceName)).sort(
@@ -1829,41 +1945,385 @@ function buildServiceManifestSnapshot(params) {
       }
     }
   }
-  const manifestBody = {
-    serviceName,
-    serviceInstanceId,
-    tasks: taskDefinitions,
-    signals: Array.from(signalDefinitions.values()).sort(
-      (left, right) => left.name.localeCompare(right.name)
-    ),
-    intents: intentDefinitions,
-    actors: actorDefinitions,
-    routines: routineDefinitions,
-    directionalTaskMaps: Array.from(directionalTaskMaps.values()).sort(
-      (left, right) => `${left.predecessor_task_name}:${left.task_name}`.localeCompare(
-        `${right.predecessor_task_name}:${right.task_name}`
-      )
-    ),
-    signalToTaskMaps: Array.from(signalTaskMaps.values()).sort(
-      (left, right) => `${left.signal_name}:${left.task_name}`.localeCompare(
-        `${right.signal_name}:${right.task_name}`
-      )
-    ),
-    intentToTaskMaps: Array.from(intentTaskMaps.values()).sort(
-      (left, right) => `${left.intent_name}:${left.task_name}`.localeCompare(
-        `${right.intent_name}:${right.task_name}`
+  const taskDefinitionsByKey = new Map(
+    taskDefinitions.map((task) => [buildTaskKey(task), task])
+  );
+  const signalDefinitionsByName = new Map(
+    Array.from(signalDefinitions.values()).map((signal) => [signal.name, signal])
+  );
+  const intentDefinitionsByName = new Map(
+    intentDefinitions.map((intent) => [intent.name, intent])
+  );
+  const actorDefinitionsByKey = new Map(
+    actorDefinitions.map((actor) => [buildActorKey(actor), actor])
+  );
+  const routineDefinitionsByKey = new Map(
+    routineDefinitions.map((routine) => [buildRoutineKey(routine), routine])
+  );
+  const routingTaskKeys = /* @__PURE__ */ new Set();
+  const routingSignalNames = /* @__PURE__ */ new Set();
+  const routingIntentNames = /* @__PURE__ */ new Set();
+  const publishedSignalTaskMaps = Array.from(signalTaskMaps.values()).filter((map) => {
+    const signal = signalDefinitionsByName.get(map.signal_name);
+    return signal?.is_meta !== true || (signal ? isRoutingCriticalMetaSignal(signal) : false);
+  }).sort(
+    (left, right) => `${left.signal_name}:${left.task_name}`.localeCompare(
+      `${right.signal_name}:${right.task_name}`
+    )
+  );
+  const publishedIntentTaskMaps = Array.from(intentTaskMaps.values()).filter((map) => {
+    const intent = intentDefinitionsByName.get(map.intent_name);
+    return intent?.is_meta !== true || (intent ? isRoutingCriticalMetaIntent(intent) : false);
+  }).sort(
+    (left, right) => `${left.intent_name}:${left.task_name}`.localeCompare(
+      `${right.intent_name}:${right.task_name}`
+    )
+  );
+  const localMetaSignalTaskMaps = Array.from(signalTaskMaps.values()).filter((map) => !publishedSignalTaskMaps.includes(map)).sort(
+    (left, right) => `${left.signal_name}:${left.task_name}`.localeCompare(
+      `${right.signal_name}:${right.task_name}`
+    )
+  );
+  const localMetaIntentTaskMaps = Array.from(intentTaskMaps.values()).filter((map) => !publishedIntentTaskMaps.includes(map)).sort(
+    (left, right) => `${left.intent_name}:${left.task_name}`.localeCompare(
+      `${right.intent_name}:${right.task_name}`
+    )
+  );
+  for (const map of publishedSignalTaskMaps) {
+    routingTaskKeys.add(
+      buildTaskKey({
+        service_name: map.service_name,
+        name: map.task_name,
+        version: map.task_version
+      })
+    );
+    routingSignalNames.add(map.signal_name);
+  }
+  for (const map of publishedIntentTaskMaps) {
+    routingTaskKeys.add(
+      buildTaskKey({
+        service_name: map.service_name,
+        name: map.task_name,
+        version: map.task_version
+      })
+    );
+    routingIntentNames.add(map.intent_name);
+  }
+  const routingTasks = Array.from(routingTaskKeys).map((key) => taskDefinitionsByKey.get(key) ?? null).filter((task) => task !== null).sort(
+    (left, right) => `${left.name}:${left.version}`.localeCompare(`${right.name}:${right.version}`)
+  );
+  const routingSignals = Array.from(routingSignalNames).map((name) => signalDefinitionsByName.get(name) ?? null).filter((signal) => signal !== null).sort((left, right) => left.name.localeCompare(right.name));
+  const routingIntents = Array.from(routingIntentNames).map((name) => intentDefinitionsByName.get(name) ?? null).filter((intent) => intent !== null).sort((left, right) => left.name.localeCompare(right.name));
+  const businessTasks = taskDefinitions.filter((task) => task.is_meta !== true && task.is_sub_meta !== true).sort(
+    (left, right) => `${left.name}:${left.version}`.localeCompare(`${right.name}:${right.version}`)
+  );
+  const businessSignals = Array.from(signalDefinitions.values()).filter((signal) => signal.is_meta !== true).sort((left, right) => left.name.localeCompare(right.name));
+  const businessIntents = intentDefinitions.filter((intent) => intent.is_meta !== true).sort((left, right) => left.name.localeCompare(right.name));
+  const businessActors = actorDefinitions.filter((actor) => actor.is_meta !== true).sort(
+    (left, right) => `${left.name}:${left.version}`.localeCompare(`${right.name}:${right.version}`)
+  );
+  const businessRoutines = routineDefinitions.filter((routine) => routine.is_meta !== true).sort(
+    (left, right) => `${left.name}:${left.version}`.localeCompare(`${right.name}:${right.version}`)
+  );
+  const businessDirectionalTaskMaps = Array.from(directionalTaskMaps.values()).filter((map) => {
+    const predecessor = taskDefinitionsByKey.get(
+      buildTaskKey({
+        service_name: map.predecessor_service_name,
+        name: map.predecessor_task_name,
+        version: map.predecessor_task_version
+      })
+    );
+    const task = taskDefinitionsByKey.get(
+      buildTaskKey({
+        service_name: map.service_name,
+        name: map.task_name,
+        version: map.task_version
+      })
+    );
+    return predecessor?.is_meta !== true && predecessor?.is_sub_meta !== true && task?.is_meta !== true && task?.is_sub_meta !== true;
+  }).sort(
+    (left, right) => `${left.predecessor_task_name}:${left.task_name}`.localeCompare(
+      `${right.predecessor_task_name}:${right.task_name}`
+    )
+  );
+  const businessActorTaskMaps = Array.from(actorTaskMaps.values()).filter((map) => {
+    const actor = actorDefinitionsByKey.get(
+      buildActorKey({
+        service_name: map.service_name,
+        name: map.actor_name,
+        version: map.actor_version
+      })
+    );
+    const task = taskDefinitionsByKey.get(
+      buildTaskKey({
+        service_name: map.service_name,
+        name: map.task_name,
+        version: map.task_version
+      })
+    );
+    return actor?.is_meta !== true && task?.is_meta !== true && task?.is_sub_meta !== true;
+  }).sort(
+    (left, right) => `${left.actor_name}:${left.task_name}`.localeCompare(
+      `${right.actor_name}:${right.task_name}`
+    )
+  );
+  const businessTaskToRoutineMaps = Array.from(taskToRoutineMaps.values()).filter((map) => {
+    const routine = routineDefinitionsByKey.get(
+      buildRoutineKey({
+        service_name: map.service_name,
+        name: map.routine_name,
+        version: map.routine_version
+      })
+    );
+    const task = taskDefinitionsByKey.get(
+      buildTaskKey({
+        service_name: map.service_name,
+        name: map.task_name,
+        version: map.task_version
+      })
+    );
+    return routine?.is_meta !== true && task?.is_meta !== true && task?.is_sub_meta !== true;
+  }).sort(
+    (left, right) => `${left.routine_name}:${left.task_name}`.localeCompare(
+      `${right.routine_name}:${right.task_name}`
+    )
+  );
+  const localMetaTasks = taskDefinitions.filter((task) => task.is_meta === true || task.is_sub_meta === true).sort(
+    (left, right) => `${left.name}:${left.version}`.localeCompare(`${right.name}:${right.version}`)
+  );
+  const localMetaSignals = Array.from(signalDefinitions.values()).filter((signal) => signal.is_meta === true).sort((left, right) => left.name.localeCompare(right.name));
+  const localMetaIntents = intentDefinitions.filter((intent) => intent.is_meta === true).sort((left, right) => left.name.localeCompare(right.name));
+  const localMetaActors = actorDefinitions.filter((actor) => actor.is_meta === true).sort(
+    (left, right) => `${left.name}:${left.version}`.localeCompare(`${right.name}:${right.version}`)
+  );
+  const localMetaRoutines = routineDefinitions.filter((routine) => routine.is_meta === true).sort(
+    (left, right) => `${left.name}:${left.version}`.localeCompare(`${right.name}:${right.version}`)
+  );
+  const localMetaDirectionalTaskMaps = Array.from(directionalTaskMaps.values()).filter((map) => !businessDirectionalTaskMaps.includes(map)).sort(
+    (left, right) => `${left.predecessor_task_name}:${left.task_name}`.localeCompare(
+      `${right.predecessor_task_name}:${right.task_name}`
+    )
+  );
+  const localMetaActorTaskMaps = Array.from(actorTaskMaps.values()).filter((map) => !businessActorTaskMaps.includes(map)).sort(
+    (left, right) => `${left.actor_name}:${left.task_name}`.localeCompare(
+      `${right.actor_name}:${right.task_name}`
+    )
+  );
+  const localMetaTaskToRoutineMaps = Array.from(taskToRoutineMaps.values()).filter((map) => !businessTaskToRoutineMaps.includes(map)).sort(
+    (left, right) => `${left.routine_name}:${left.task_name}`.localeCompare(
+      `${right.routine_name}:${right.task_name}`
+    )
+  );
+  const businessLocalMetaTaskKeys = /* @__PURE__ */ new Set();
+  const businessLocalMetaSignalNames = /* @__PURE__ */ new Set();
+  const businessLocalMetaIntentNames = /* @__PURE__ */ new Set();
+  const businessLocalMetaActorKeys = /* @__PURE__ */ new Set();
+  const businessLocalMetaRoutineKeys = /* @__PURE__ */ new Set();
+  for (const map of localMetaSignalTaskMaps) {
+    businessLocalMetaSignalNames.add(map.signal_name);
+    businessLocalMetaTaskKeys.add(
+      buildTaskKey({
+        service_name: map.service_name,
+        name: map.task_name,
+        version: map.task_version
+      })
+    );
+  }
+  for (const map of localMetaIntentTaskMaps) {
+    businessLocalMetaIntentNames.add(map.intent_name);
+    businessLocalMetaTaskKeys.add(
+      buildTaskKey({
+        service_name: map.service_name,
+        name: map.task_name,
+        version: map.task_version
+      })
+    );
+  }
+  for (const map of localMetaActorTaskMaps) {
+    businessLocalMetaActorKeys.add(
+      buildActorKey({
+        service_name: map.service_name,
+        name: map.actor_name,
+        version: map.actor_version
+      })
+    );
+    businessLocalMetaTaskKeys.add(
+      buildTaskKey({
+        service_name: map.service_name,
+        name: map.task_name,
+        version: map.task_version
+      })
+    );
+  }
+  for (const map of localMetaTaskToRoutineMaps) {
+    businessLocalMetaRoutineKeys.add(
+      buildRoutineKey({
+        service_name: map.service_name,
+        name: map.routine_name,
+        version: map.routine_version
+      })
+    );
+    businessLocalMetaTaskKeys.add(
+      buildTaskKey({
+        service_name: map.service_name,
+        name: map.task_name,
+        version: map.task_version
+      })
+    );
+  }
+  const businessLocalMetaTasks = Array.from(businessLocalMetaTaskKeys).map((key) => taskDefinitionsByKey.get(key) ?? null).filter(
+    (task) => task !== null && (task.is_meta === true || task.is_sub_meta === true)
+  ).sort(
+    (left, right) => `${left.name}:${left.version}`.localeCompare(`${right.name}:${right.version}`)
+  );
+  const businessLocalMetaSignals = Array.from(businessLocalMetaSignalNames).map((name) => signalDefinitionsByName.get(name) ?? null).filter(
+    (signal) => signal !== null && signal.is_meta === true
+  ).sort((left, right) => left.name.localeCompare(right.name));
+  const businessLocalMetaIntents = Array.from(businessLocalMetaIntentNames).map((name) => intentDefinitionsByName.get(name) ?? null).filter(
+    (intent) => intent !== null && intent.is_meta === true
+  ).sort((left, right) => left.name.localeCompare(right.name));
+  const businessLocalMetaActors = Array.from(businessLocalMetaActorKeys).map((key) => actorDefinitionsByKey.get(key) ?? null).filter(
+    (actor) => actor !== null && actor.is_meta === true
+  ).sort(
+    (left, right) => `${left.name}:${left.version}`.localeCompare(`${right.name}:${right.version}`)
+  );
+  const businessLocalMetaRoutines = Array.from(businessLocalMetaRoutineKeys).map((key) => routineDefinitionsByKey.get(key) ?? null).filter(
+    (routine) => routine !== null && routine.is_meta === true
+  ).sort(
+    (left, right) => `${left.name}:${left.version}`.localeCompare(`${right.name}:${right.version}`)
+  );
+  const cumulativeTasks = publicationLayer === "routing_capability" ? routingTasks : publicationLayer === "business_structural" ? Array.from(
+    new Map(
+      [...routingTasks, ...businessTasks, ...businessLocalMetaTasks].map((task) => [
+        buildTaskKey(task),
+        task
+      ])
+    ).values()
+  ).sort(
+    (left, right) => `${left.name}:${left.version}`.localeCompare(`${right.name}:${right.version}`)
+  ) : Array.from(
+    new Map(
+      [...routingTasks, ...businessTasks, ...localMetaTasks].map((task) => [
+        buildTaskKey(task),
+        task
+      ])
+    ).values()
+  ).sort(
+    (left, right) => `${left.name}:${left.version}`.localeCompare(`${right.name}:${right.version}`)
+  );
+  const cumulativeSignals = publicationLayer === "routing_capability" ? routingSignals : publicationLayer === "business_structural" ? Array.from(
+    new Map(
+      [...routingSignals, ...businessSignals, ...businessLocalMetaSignals].map(
+        (signal) => [signal.name, signal]
       )
-    ),
-    actorTaskMaps: Array.from(actorTaskMaps.values()).sort(
-      (left, right) => `${left.actor_name}:${left.task_name}`.localeCompare(
-        `${right.actor_name}:${right.task_name}`
+    ).values()
+  ).sort((left, right) => left.name.localeCompare(right.name)) : Array.from(
+    new Map(
+      [...routingSignals, ...businessSignals, ...localMetaSignals].map((signal) => [
+        signal.name,
+        signal
+      ])
+    ).values()
+  ).sort((left, right) => left.name.localeCompare(right.name));
+  const cumulativeIntents = publicationLayer === "routing_capability" ? routingIntents : publicationLayer === "business_structural" ? Array.from(
+    new Map(
+      [...routingIntents, ...businessIntents, ...businessLocalMetaIntents].map(
+        (intent) => [intent.name, intent]
       )
-    ),
-    taskToRoutineMaps: Array.from(taskToRoutineMaps.values()).sort(
-      (left, right) => `${left.routine_name}:${left.task_name}`.localeCompare(
-        `${right.routine_name}:${right.task_name}`
+    ).values()
+  ).sort((left, right) => left.name.localeCompare(right.name)) : Array.from(
+    new Map(
+      [...routingIntents, ...businessIntents, ...localMetaIntents].map((intent) => [
+        intent.name,
+        intent
+      ])
+    ).values()
+  ).sort((left, right) => left.name.localeCompare(right.name));
+  const cumulativeActors = publicationLayer === "routing_capability" ? [] : publicationLayer === "business_structural" ? Array.from(
+    new Map(
+      [...businessActors, ...businessLocalMetaActors].map((actor) => [
+        buildActorKey(actor),
+        actor
+      ])
+    ).values()
+  ).sort(
+    (left, right) => `${left.name}:${left.version}`.localeCompare(`${right.name}:${right.version}`)
+  ) : Array.from(
+    new Map(
+      [...businessActors, ...localMetaActors].map((actor) => [
+        buildActorKey(actor),
+        actor
+      ])
+    ).values()
+  ).sort(
+    (left, right) => `${left.name}:${left.version}`.localeCompare(`${right.name}:${right.version}`)
+  );
+  const cumulativeRoutines = publicationLayer === "routing_capability" ? [] : publicationLayer === "business_structural" ? Array.from(
+    new Map(
+      [...businessRoutines, ...businessLocalMetaRoutines].map((routine) => [
+        buildRoutineKey(routine),
+        routine
+      ])
+    ).values()
+  ).sort(
+    (left, right) => `${left.name}:${left.version}`.localeCompare(`${right.name}:${right.version}`)
+  ) : Array.from(
+    new Map(
+      [...businessRoutines, ...localMetaRoutines].map((routine) => [
+        buildRoutineKey(routine),
+        routine
+      ])
+    ).values()
+  ).sort(
+    (left, right) => `${left.name}:${left.version}`.localeCompare(`${right.name}:${right.version}`)
+  );
+  const cumulativeDirectionalTaskMaps = publicationLayer === "routing_capability" ? [] : publicationLayer === "business_structural" ? businessDirectionalTaskMaps : Array.from(
+    new Map(
+      [...businessDirectionalTaskMaps, ...localMetaDirectionalTaskMaps].map(
+        (map) => [
+          `${map.predecessor_service_name}|${map.predecessor_task_name}|${map.predecessor_task_version}|${map.service_name}|${map.task_name}|${map.task_version}`,
+          map
+        ]
       )
-    )
+    ).values()
+  );
+  const cumulativeActorTaskMaps = publicationLayer === "routing_capability" ? [] : publicationLayer === "business_structural" ? Array.from(
+    new Map(
+      [...businessActorTaskMaps, ...localMetaActorTaskMaps].map((map) => [
+        `${map.service_name}|${map.actor_name}|${map.actor_version}|${map.task_name}|${map.task_version}|${map.mode}`,
+        map
+      ])
+    ).values()
+  ) : Array.from(
+    new Map(
+      [...businessActorTaskMaps, ...localMetaActorTaskMaps].map((map) => [
+        `${map.service_name}|${map.actor_name}|${map.actor_version}|${map.task_name}|${map.task_version}|${map.mode}`,
+        map
+      ])
+    ).values()
+  );
+  const cumulativeTaskToRoutineMaps = publicationLayer === "routing_capability" ? [] : publicationLayer === "business_structural" ? businessTaskToRoutineMaps : Array.from(
+    new Map(
+      [...businessTaskToRoutineMaps, ...localMetaTaskToRoutineMaps].map((map) => [
+        `${map.service_name}|${map.task_name}|${map.task_version}|${map.routine_name}|${map.routine_version}`,
+        map
+      ])
+    ).values()
+  );
+  const manifestBody = {
+    serviceName,
+    serviceInstanceId,
+    publicationLayer,
+    tasks: cumulativeTasks,
+    signals: cumulativeSignals,
+    intents: cumulativeIntents,
+    actors: cumulativeActors,
+    routines: cumulativeRoutines,
+    directionalTaskMaps: cumulativeDirectionalTaskMaps,
+    signalToTaskMaps: publicationLayer === "routing_capability" ? publishedSignalTaskMaps : publicationLayer === "local_meta_structural" ? [...publishedSignalTaskMaps, ...localMetaSignalTaskMaps] : [...publishedSignalTaskMaps, ...localMetaSignalTaskMaps],
+    intentToTaskMaps: publicationLayer === "routing_capability" ? publishedIntentTaskMaps : publicationLayer === "local_meta_structural" ? [...publishedIntentTaskMaps, ...localMetaIntentTaskMaps] : [...publishedIntentTaskMaps, ...localMetaIntentTaskMaps],
+    actorTaskMaps: cumulativeActorTaskMaps,
+    taskToRoutineMaps: cumulativeTaskToRoutineMaps
   };
   return {
     ...manifestBody,
@@ -2001,7 +2461,7 @@ var SERVICE_REGISTRY_TRACE_SERVICE2 = (process.env.CADENZA_SERVICE_REGISTRY_TRAC
 function shouldTraceServiceRegistry(serviceName) {
   return SERVICE_REGISTRY_TRACE_SERVICE2.length > 0 && serviceName === SERVICE_REGISTRY_TRACE_SERVICE2;
 }
-function buildServiceRegistryInsertQueryData(ctx, queryData) {
+function buildServiceRegistryInsertQueryData(tableName, ctx, queryData) {
   const joinedContexts = Array.isArray(ctx.joinedContexts) ? ctx.joinedContexts : [];
   const getJoinedValue = (key) => {
     for (let index = joinedContexts.length - 1; index >= 0; index -= 1) {
@@ -2019,7 +2479,8 @@ function buildServiceRegistryInsertQueryData(ctx, queryData) {
   if (!Object.prototype.hasOwnProperty.call(queryData, "onConflict")) {
     delete nextQueryData.onConflict;
   }
-  const resolvedData = Object.prototype.hasOwnProperty.call(ctx, "data") || ctx.data !== void 0 ? ctx.data : getJoinedValue("data");
+  const preferRegistrationData = tableName === "service" || tableName === "service_instance" || tableName === "service_instance_transport";
+  const resolvedData = preferRegistrationData ? registrationData ?? (Object.prototype.hasOwnProperty.call(ctx, "data") || ctx.data !== void 0 ? ctx.data : getJoinedValue("data")) : Object.prototype.hasOwnProperty.call(ctx, "data") || ctx.data !== void 0 ? ctx.data : getJoinedValue("data");
   const resolvedBatch = Object.prototype.hasOwnProperty.call(ctx, "batch") || ctx.batch !== void 0 ? ctx.batch : getJoinedValue("batch");
   const nextData = resolvedData !== void 0 ? resolvedData && typeof resolvedData === "object" ? { ...resolvedData } : resolvedData : registrationData && typeof registrationData === "object" && !Array.isArray(registrationData) ? { ...registrationData } : registrationData;
   if (nextData !== void 0) {
@@ -2046,8 +2507,114 @@ function sanitizeServiceRegistryInsertExecutionContext(ctx) {
   delete sanitized.returnedValue;
   delete sanitized.queryData;
   delete sanitized.onConflict;
+  delete sanitized.task;
+  delete sanitized.routine;
+  delete sanitized.httpServer;
+  delete sanitized.service;
+  delete sanitized.serviceInstance;
+  delete sanitized.joinedContexts;
+  delete sanitized.__declaredTransports;
+  delete sanitized.__resolverOriginalContext;
+  delete sanitized.__resolverQueryData;
+  return sanitized;
+}
+function sanitizeAuthorityBootstrapDelegationContext(ctx) {
+  const sanitized = stripDelegationRequestSnapshot({
+    ...ctx
+  });
+  delete sanitized.__resolverOriginalContext;
+  delete sanitized.__resolverQueryData;
+  delete sanitized.joinedContexts;
+  delete sanitized.httpServer;
+  delete sanitized.service;
+  delete sanitized.serviceInstance;
+  delete sanitized.task;
+  delete sanitized.routine;
+  delete sanitized.__declaredTransports;
+  const queryData = sanitized.queryData && typeof sanitized.queryData === "object" ? { ...sanitized.queryData } : null;
+  if (queryData) {
+    delete queryData.joinedContexts;
+    sanitized.queryData = queryData;
+  }
   return sanitized;
 }
+function cloneServiceRegistryContextValue(value) {
+  if (value instanceof Date) {
+    return new Date(value.getTime());
+  }
+  if (Array.isArray(value)) {
+    return value.map(
+      (entry) => cloneServiceRegistryContextValue(entry)
+    );
+  }
+  if (value && typeof value === "object") {
+    const clone = {};
+    for (const [key, nestedValue] of Object.entries(value)) {
+      clone[key] = cloneServiceRegistryContextValue(nestedValue);
+    }
+    return clone;
+  }
+  return value;
+}
+function buildServiceRegistryResolverOriginalContext(tableName, ctx, queryData) {
+  const originalContext = {};
+  for (const key of [
+    "__serviceName",
+    "serviceName",
+    "__serviceInstanceId",
+    "serviceInstanceId",
+    "__registrationData",
+    "__reason",
+    "__syncing",
+    "__syncSourceServiceName",
+    "__preferredTransportProtocol",
+    "__networkMode",
+    "__securityProfile",
+    "__loadBalance",
+    "__cadenzaDBConnect",
+    "__isFrontend",
+    "__isDatabase",
+    "__retryCount",
+    "__retries",
+    "__triedInstances"
+  ]) {
+    if (ctx[key] !== void 0) {
+      originalContext[key] = cloneServiceRegistryContextValue(ctx[key]);
+    }
+  }
+  if (queryData.data !== void 0) {
+    originalContext.data = cloneServiceRegistryContextValue(queryData.data);
+  }
+  if (queryData.batch !== void 0) {
+    originalContext.batch = cloneServiceRegistryContextValue(queryData.batch);
+  }
+  if (Object.prototype.hasOwnProperty.call(queryData, "onConflict")) {
+    originalContext.queryData = {
+      data: queryData.data !== void 0 ? cloneServiceRegistryContextValue(queryData.data) : void 0,
+      batch: queryData.batch !== void 0 ? cloneServiceRegistryContextValue(queryData.batch) : void 0,
+      onConflict: cloneServiceRegistryContextValue(queryData.onConflict)
+    };
+  } else if (queryData.data !== void 0 || queryData.batch !== void 0) {
+    originalContext.queryData = {
+      data: queryData.data !== void 0 ? cloneServiceRegistryContextValue(queryData.data) : void 0,
+      batch: queryData.batch !== void 0 ? cloneServiceRegistryContextValue(queryData.batch) : void 0
+    };
+  }
+  if (tableName === "service_instance") {
+    for (const key of [
+      "__transportData",
+      "transportData",
+      "__useSocket",
+      "__retryCount",
+      "__isFrontend"
+    ]) {
+      if (ctx[key] !== void 0) {
+        originalContext[key] = cloneServiceRegistryContextValue(ctx[key]);
+      }
+    }
+  }
+  return originalContext;
+}
 function clearTransientRoutingErrorState(context) {
   delete context.errored;
   delete context.failed;
@@ -2103,7 +2670,8 @@ function normalizeServiceRegistryInsertResult(tableName, ctx, queryData, rawResu
   delete result.__resolverOriginalContext;
   delete result.__resolverQueryData;
   const normalizedQueryData = result.queryData && typeof result.queryData === "object" ? { ...result.queryData } : { ...queryData };
-  const resolvedData = result.data ?? normalizedQueryData.data ?? queryData.data ?? ctx.data ?? ctx.__registrationData;
+  const preferRequestedData = tableName === "service" || tableName === "service_instance" || tableName === "service_instance_transport";
+  const resolvedData = preferRequestedData ? normalizedQueryData.data ?? queryData.data ?? ctx.data ?? ctx.__registrationData ?? result.data : result.data ?? normalizedQueryData.data ?? queryData.data ?? ctx.data ?? ctx.__registrationData;
   if (resolvedData !== void 0 && result.data === void 0) {
     result.data = resolvedData;
   }
@@ -2133,6 +2701,7 @@ function normalizeServiceRegistryInsertResult(tableName, ctx, queryData, rawResu
     ).trim();
     if (resolvedServiceName) {
       result.__serviceName = resolvedServiceName;
+      result.serviceName = resolvedServiceName;
     }
   }
   const resolvedLocalServiceInstanceId = String(
@@ -2141,6 +2710,18 @@ function normalizeServiceRegistryInsertResult(tableName, ctx, queryData, rawResu
   if (resolvedLocalServiceInstanceId) {
     result.__serviceInstanceId = resolvedLocalServiceInstanceId;
   }
+  if (tableName === "service_instance") {
+    const resolvedServiceName = String(
+      ctx.__serviceName ?? resolveServiceNameFromContext(ctx) ?? resolvedData?.service_name ?? resolvedData?.serviceName ?? ""
+    ).trim();
+    if (resolvedServiceName) {
+      result.__serviceName = resolvedServiceName;
+      result.serviceName = resolvedServiceName;
+    }
+    if (resolvedLocalServiceInstanceId) {
+      result.serviceInstanceId = resolvedLocalServiceInstanceId;
+    }
+  }
   if (tableName === "service_instance" || tableName === "service_instance_transport") {
     const resolvedUuid = String(
       result.uuid ?? resolvedData?.uuid ?? ctx.__serviceInstanceId ?? ""
@@ -2240,9 +2821,15 @@ function resolveServiceRegistryInsertTask(tableName, queryData = {}, options = {
         ctx
       );
       const nextQueryData = buildServiceRegistryInsertQueryData(
+        tableName,
         sanitizedContext,
         queryData
       );
+      const resolverOriginalContext = buildServiceRegistryResolverOriginalContext(
+        tableName,
+        sanitizedContext,
+        nextQueryData
+      );
       const delegationContext = ensureDelegationContextMetadata({
         ...sanitizedContext,
         data: nextQueryData.data !== void 0 ? nextQueryData.data : sanitizedContext.data,
@@ -2255,9 +2842,7 @@ function resolveServiceRegistryInsertTask(tableName, queryData = {}, options = {
       delegationContext.__metadata.__blockRemoteExecution = delegationContext.__metadata.__blockRemoteExecution ?? delegationContext.__blockRemoteExecution ?? false;
       const nextContext = {
         ...delegationContext,
-        __resolverOriginalContext: {
-          ...sanitizedContext
-        },
+        __resolverOriginalContext: resolverOriginalContext,
         __resolverQueryData: nextQueryData
       };
       if (tableName === "service_instance_transport" && shouldTraceServiceRegistry(
@@ -2429,6 +3014,7 @@ function resolveServiceRegistryInsertTask(tableName, queryData = {}, options = {
       if (bootstrapAuthorityInsertSpec) {
         const sanitizedContext = sanitizeServiceRegistryInsertExecutionContext(ctx);
         const nextQueryData = buildServiceRegistryInsertQueryData(
+          tableName,
           sanitizedContext,
           queryData
         );
@@ -2863,6 +3449,9 @@ var ServiceRegistry = class _ServiceRegistry {
           ctx.deleted ?? ctx.serviceInstance?.deleted ?? ctx.data?.deleted
         );
         if (uuid9 === this.serviceInstanceId) return;
+        if (serviceName === this.serviceName) {
+          return false;
+        }
         if (deleted) {
           const existingInstance = this.instances.get(serviceName)?.find((instance) => instance.uuid === uuid9);
           const indexToDelete = this.instances.get(serviceName)?.findIndex((i) => i.uuid === uuid9) ?? -1;
@@ -2949,9 +3538,6 @@ var ServiceRegistry = class _ServiceRegistry {
             emit2
           );
         }
-        if (this.serviceName === serviceName) {
-          return false;
-        }
         if (trackedInstance?.isFrontend) {
           return true;
         }
@@ -3005,6 +3591,9 @@ var ServiceRegistry = class _ServiceRegistry {
         if (!ownerInstance) {
           return false;
         }
+        if (ownerInstance.serviceName === this.serviceName && ownerInstance.uuid !== this.serviceInstanceId) {
+          return false;
+        }
         if (transport.deleted) {
           this.clearTransportFailureState(ownerInstance.uuid, transport.uuid);
           const transportKey = this.buildTransportRouteKey(
@@ -5431,6 +6020,8 @@ var ServiceRegistry = class _ServiceRegistry {
         seenSignalMaps,
         (row) => `${String(row.service_name ?? row.serviceName ?? "").trim()}|${String(
           row.signal_name ?? row.signalName ?? ""
+        ).trim()}|${String(row.task_name ?? row.taskName ?? "").trim()}|${String(
+          row.task_version ?? row.taskVersion ?? 1
         ).trim()}`
       );
       pushUnique(
@@ -5465,6 +6056,8 @@ var ServiceRegistry = class _ServiceRegistry {
             seenSignalMaps,
             (entry) => `${String(entry.service_name ?? entry.serviceName ?? "").trim()}|${String(
               entry.signal_name ?? entry.signalName ?? ""
+            ).trim()}|${String(entry.task_name ?? entry.taskName ?? "").trim()}|${String(
+              entry.task_version ?? entry.taskVersion ?? 1
             ).trim()}`
           );
           continue;
@@ -5497,7 +6090,36 @@ var ServiceRegistry = class _ServiceRegistry {
         }
       }
     }
-    const latestManifestSnapshots = selectLatestServiceManifestSnapshots(manifestSnapshots);
+    const activeServiceInstanceIds = new Set(
+      serviceInstances.filter((row) => row.is_active === true || row.isActive === true).map((row) => String(row.uuid ?? "").trim()).filter((uuid9) => uuid9.length > 0)
+    );
+    const filteredServiceInstances = activeServiceInstanceIds.size > 0 ? serviceInstances.filter(
+      (row) => activeServiceInstanceIds.has(String(row.uuid ?? "").trim())
+    ) : serviceInstances;
+    const filteredServiceInstanceTransports = activeServiceInstanceIds.size > 0 ? serviceInstanceTransports.filter(
+      (row) => activeServiceInstanceIds.has(
+        String(row.service_instance_id ?? row.serviceInstanceId ?? "").trim()
+      )
+    ) : serviceInstanceTransports;
+    const filteredManifestSnapshots = activeServiceInstanceIds.size > 0 ? manifestSnapshots.filter(
+      (snapshot) => activeServiceInstanceIds.has(snapshot.serviceInstanceId)
+    ) : manifestSnapshots;
+    const activeServiceNames = new Set(
+      filteredServiceInstances.map((row) => String(row.service_name ?? row.serviceName ?? "").trim()).filter((serviceName) => serviceName.length > 0)
+    );
+    const filteredSignalToTaskMaps = activeServiceNames.size > 0 ? signalToTaskMaps.filter(
+      (row) => activeServiceNames.has(
+        String(row.service_name ?? row.serviceName ?? "").trim()
+      )
+    ) : signalToTaskMaps;
+    const filteredIntentToTaskMaps = activeServiceNames.size > 0 ? intentToTaskMaps.filter(
+      (row) => activeServiceNames.has(
+        String(row.service_name ?? row.serviceName ?? "").trim()
+      )
+    ) : intentToTaskMaps;
+    const hasExplicitSignalRoutingRows = filteredSignalToTaskMaps.length > 0;
+    const hasExplicitIntentRoutingRows = filteredIntentToTaskMaps.length > 0;
+    const latestManifestSnapshots = selectLatestServiceManifestSnapshots(filteredManifestSnapshots);
     const explodedManifest = explodeServiceManifestSnapshots(
       latestManifestSnapshots
     );
@@ -5577,29 +6199,33 @@ var ServiceRegistry = class _ServiceRegistry {
         row.task_version ?? 1
       ).trim()}`
     );
-    pushUnique(
-      explodedManifest.signalToTaskMaps,
-      signalToTaskMaps,
-      seenSignalMaps,
-      (row) => `${String(row.signal_name ?? "").trim()}|${String(
-        row.service_name ?? ""
-      ).trim()}|${String(row.task_name ?? "").trim()}|${String(
-        row.task_version ?? 1
-      ).trim()}`
-    );
-    pushUnique(
-      explodedManifest.intentToTaskMaps,
-      intentToTaskMaps,
-      seenIntentMaps,
-      (row) => `${String(row.intent_name ?? "").trim()}|${String(
-        row.service_name ?? ""
-      ).trim()}|${String(row.task_name ?? "").trim()}|${String(
-        row.task_version ?? 1
-      ).trim()}`
-    );
+    if (!hasExplicitSignalRoutingRows) {
+      pushUnique(
+        explodedManifest.signalToTaskMaps,
+        filteredSignalToTaskMaps,
+        seenSignalMaps,
+        (row) => `${String(row.signal_name ?? "").trim()}|${String(
+          row.service_name ?? ""
+        ).trim()}|${String(row.task_name ?? "").trim()}|${String(
+          row.task_version ?? 1
+        ).trim()}`
+      );
+    }
+    if (!hasExplicitIntentRoutingRows) {
+      pushUnique(
+        explodedManifest.intentToTaskMaps,
+        filteredIntentToTaskMaps,
+        seenIntentMaps,
+        (row) => `${String(row.intent_name ?? "").trim()}|${String(
+          row.service_name ?? ""
+        ).trim()}|${String(row.task_name ?? "").trim()}|${String(
+          row.task_version ?? 1
+        ).trim()}`
+      );
+    }
     return {
-      serviceInstances,
-      serviceInstanceTransports,
+      serviceInstances: filteredServiceInstances,
+      serviceInstanceTransports: filteredServiceInstanceTransports,
       serviceManifests,
       tasks,
       signals,
@@ -5609,8 +6235,8 @@ var ServiceRegistry = class _ServiceRegistry {
       directionalTaskMaps,
       actorTaskMaps,
       taskToRoutineMaps,
-      signalToTaskMaps,
-      intentToTaskMaps
+      signalToTaskMaps: filteredSignalToTaskMaps,
+      intentToTaskMaps: filteredIntentToTaskMaps
     };
   }
   buildRemoteIntentDeputyKey(map) {
@@ -6039,10 +6665,11 @@ var ServiceRegistry = class _ServiceRegistry {
     const controller = typeof AbortController === "function" ? new AbortController() : null;
     const timeoutId = controller ? setTimeout(() => controller.abort(), timeoutMs) : null;
     try {
+      const sanitizedContext = sanitizeAuthorityBootstrapDelegationContext(context);
       const requestBody = stripDelegationRequestSnapshot(
         ensureDelegationContextMetadata(
           attachDelegationRequestSnapshot({
-            ...context,
+            ...sanitizedContext,
             __remoteRoutineName: remoteRoutineName,
             __serviceName: "CadenzaDB",
             __localServiceName: this.serviceName,
@@ -6056,7 +6683,7 @@ var ServiceRegistry = class _ServiceRegistry {
             __fetchId: target.fetchId,
             fetchId: target.fetchId,
             __metadata: {
-              ...context.__metadata && typeof context.__metadata === "object" ? context.__metadata : {},
+              ...sanitizedContext.__metadata && typeof sanitizedContext.__metadata === "object" ? sanitizedContext.__metadata : {},
               __timeout: timeoutMs,
               __syncing: true,
               __authorityBootstrapChannel: true
@@ -6074,22 +6701,22 @@ var ServiceRegistry = class _ServiceRegistry {
       });
       if ("ok" in response && response.ok === false) {
         return {
-          ...context,
+          ...sanitizedContext,
           __error: `Bootstrap authority delegation failed with HTTP ${response.status}`,
           errored: true
         };
       }
       const payload = typeof response.json === "function" ? await response.json() : response;
       return payload && typeof payload === "object" ? {
-        ...context,
+        ...sanitizedContext,
         ...payload
       } : {
-        ...context,
+        ...sanitizedContext,
         returnedValue: payload
       };
     } catch (error) {
       return {
-        ...context,
+        ...sanitizeAuthorityBootstrapDelegationContext(context),
         __error: error instanceof Error ? error.message : String(error),
         errored: true
       };
@@ -6199,16 +6826,35 @@ var ServiceRegistry = class _ServiceRegistry {
     const authorityFullSyncResponderTask = CadenzaService.createMetaTask(
       BOOTSTRAP_FULL_SYNC_RESPONDER_TASK_NAME,
       async (ctx) => {
+        const queryOptionalAuthorityRoutingRows = async (tableName) => {
+          try {
+            return await DatabaseController.instance.queryAuthorityTableRows(
+              tableName
+            );
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (message.includes(
+              `Table '${tableName}' is not registered on the CadenzaDB PostgresActor`
+            )) {
+              return [];
+            }
+            throw error;
+          }
+        };
         const [
           serviceInstances,
           serviceInstanceTransports,
-          serviceManifests
+          serviceManifests,
+          signalToTaskMaps,
+          intentToTaskMaps
         ] = await Promise.all([
           DatabaseController.instance.queryAuthorityTableRows("service_instance"),
           DatabaseController.instance.queryAuthorityTableRows(
             "service_instance_transport"
           ),
-          DatabaseController.instance.queryAuthorityTableRows("service_manifest")
+          DatabaseController.instance.queryAuthorityTableRows("service_manifest"),
+          queryOptionalAuthorityRoutingRows("signal_to_task_map"),
+          queryOptionalAuthorityRoutingRows("intent_to_task_map")
         ]);
         return {
           ...ctx,
@@ -6216,7 +6862,9 @@ var ServiceRegistry = class _ServiceRegistry {
           ...this.collectBootstrapFullSyncPayload({
             serviceInstances,
             serviceInstanceTransports,
-            serviceManifests
+            serviceManifests,
+            signalToTaskMaps,
+            intentToTaskMaps
           })
         };
       },
@@ -11086,8 +11734,8 @@ var SocketController = class _SocketController {
               }
               const routedDelegateCtx = stripTransportSelectionRoutingContext(delegateCtx);
               const normalizedDelegateCtx = ensureDelegationContextMetadata(
-                attachDelegationRequestSnapshot(
-                  stripDelegationRequestSnapshot(routedDelegateCtx)
+                restoreDelegationRequestSnapshot(
+                  attachDelegationRequestSnapshot(routedDelegateCtx)
                 )
               );
               delete normalizedDelegateCtx.__isSubMeta;
@@ -11160,13 +11808,11 @@ var SocketController = class _SocketController {
                 return resolvedResultContext;
               } catch (error) {
                 const message = error instanceof Error ? error.message : String(error);
-                const failedContext = {
-                  __signalName: "meta.socket_client.delegate_failed",
-                  errored: true,
-                  __error: message,
-                  ...normalizedDelegateCtx,
-                  ...normalizedDelegateCtx.__metadata
-                };
+                const failedContext = buildDelegationFailureContext(
+                  "meta.socket_client.delegate_failed",
+                  normalizedDelegateCtx,
+                  error
+                );
                 if (deputyExecId) {
                   emitter(`meta.socket_client.delegated:${deputyExecId}`, {
                     ...failedContext,
@@ -12173,12 +12819,58 @@ var RuntimeValidationController = class _RuntimeValidationController {
 // src/graph/controllers/registerActorSessionPersistence.ts
 import { META_ACTOR_SESSION_STATE_PERSIST_INTENT } from "@cadenza.io/core";
 var ACTOR_SESSION_STATE_PERSIST_CONCURRENCY = 20;
+var META_ACTOR_SESSION_STATE_HYDRATE_INTENT = "meta-actor-session-state-hydrate";
 var ACTOR_SESSION_TRACE_ENABLED2 = process.env.CADENZA_ACTOR_SESSION_TRACE === "1" || process.env.CADENZA_ACTOR_SESSION_TRACE === "true";
+function findNestedContextValue(ctx, key) {
+  if (!ctx || typeof ctx !== "object") {
+    return void 0;
+  }
+  if (Object.prototype.hasOwnProperty.call(ctx, key) || ctx[key] !== void 0) {
+    return ctx[key];
+  }
+  const joinedContexts = Array.isArray(ctx.joinedContexts) ? ctx.joinedContexts : [];
+  for (let index = joinedContexts.length - 1; index >= 0; index -= 1) {
+    const nested = joinedContexts[index];
+    if (!nested || typeof nested !== "object") {
+      continue;
+    }
+    const nestedValue = findNestedContextValue(nested, key);
+    if (nestedValue !== void 0) {
+      return nestedValue;
+    }
+  }
+  return void 0;
+}
+function resolveActorSessionStateRow(ctx) {
+  const singular = findNestedContextValue(ctx, "actorSessionState");
+  if (singular && typeof singular === "object" && !Array.isArray(singular)) {
+    return singular;
+  }
+  const plural = findNestedContextValue(ctx, "actorSessionStates");
+  if (Array.isArray(plural)) {
+    const first = plural.find(
+      (entry) => entry && typeof entry === "object" && !Array.isArray(entry)
+    );
+    if (first) {
+      return first;
+    }
+  }
+  const rows = findNestedContextValue(ctx, "rows");
+  if (Array.isArray(rows)) {
+    const first = rows.find(
+      (entry) => entry && typeof entry === "object" && !Array.isArray(entry)
+    );
+    if (first) {
+      return first;
+    }
+  }
+  return null;
+}
 function shouldAssumeSuccessfulActorSessionRowCount(ctx) {
   return ctx.__success === true && ctx.rowCount === void 0 && ctx.__status === "success" && ctx.__serviceName === "CadenzaDB" && ctx.__localTaskName === "Insert actor_session_state in CadenzaDB";
 }
 function registerActorSessionPersistenceTasks() {
-  if (CadenzaService.get("Persist actor session state")) {
+  if (CadenzaService.get("Persist actor session state") && CadenzaService.get("Hydrate actor session state")) {
     return;
   }
   const localActorSessionTaskOptions = {
@@ -12195,6 +12887,14 @@ function registerActorSessionPersistenceTasks() {
       isSubMeta: true
     }
   );
+  const actorSessionStateQueryTask = CadenzaService.getLocalCadenzaDBQueryTask("actor_session_state") ?? CadenzaService.get("dbQueryActorSessionState") ?? CadenzaService.get("Query actor_session_state in CadenzaDB") ?? CadenzaService.createCadenzaDBQueryTask(
+    "actor_session_state",
+    {},
+    {
+      concurrency: ACTOR_SESSION_STATE_PERSIST_CONCURRENCY,
+      isSubMeta: true
+    }
+  );
   const validateActorSessionStatePersistenceTask = CadenzaService.createMetaTask(
     "Validate actor session state persistence",
     (ctx) => {
@@ -12228,6 +12928,103 @@ function registerActorSessionPersistenceTasks() {
   const insertAndValidateActorSessionStateTask = actorSessionStateInsertTask.then(
     validateActorSessionStatePersistenceTask
   );
+  const validateActorSessionStateHydrationTask = CadenzaService.createMetaTask(
+    "Validate actor session state hydration",
+    (ctx) => {
+      if (ctx.errored || ctx.failed || ctx.__success !== true) {
+        throw new Error(
+          String(
+            ctx.__error ?? ctx.error ?? "actor_session_state hydration query failed"
+          )
+        );
+      }
+      const row = resolveActorSessionStateRow(ctx);
+      if (!row) {
+        return {
+          __success: true,
+          hydrated: false
+        };
+      }
+      const expiresAt = typeof row.expiresAt === "string" ? row.expiresAt : typeof row.expires_at === "string" ? row.expires_at : null;
+      const expiresAtMs = expiresAt ? Date.parse(expiresAt) : Number.NaN;
+      if (Number.isFinite(expiresAtMs) && expiresAtMs <= Date.now()) {
+        return {
+          __success: true,
+          hydrated: false
+        };
+      }
+      const durableState = row.durableState ?? row.durable_state ?? null;
+      const durableVersion = Number(
+        row.durableVersion ?? row.durable_version ?? Number.NaN
+      );
+      if (typeof durableState !== "object" || durableState === null || Array.isArray(durableState)) {
+        throw new Error("actor_session_state durable_state must be a non-null object");
+      }
+      if (!Number.isInteger(durableVersion) || durableVersion < 0) {
+        throw new Error(
+          "actor_session_state durable_version must be a non-negative integer"
+        );
+      }
+      return {
+        __success: true,
+        hydrated: true,
+        actor_name: row.actorName ?? row.actor_name,
+        actor_version: row.actorVersion ?? row.actor_version,
+        actor_key: row.actorKey ?? row.actor_key,
+        service_name: row.serviceName ?? row.service_name,
+        durable_state: durableState,
+        durable_version: durableVersion
+      };
+    },
+    "Validates and normalizes hydrated actor_session_state rows.",
+    localActorSessionTaskOptions
+  );
+  const queryAndValidateActorSessionStateTask = actorSessionStateQueryTask.then(
+    validateActorSessionStateHydrationTask
+  );
+  CadenzaService.createMetaTask(
+    "Hydrate actor session state",
+    (ctx) => {
+      const actorName = typeof ctx.actor_name === "string" ? ctx.actor_name.trim() : "";
+      const actorKey = typeof ctx.actor_key === "string" ? ctx.actor_key.trim() : "";
+      const actorVersion = Number(ctx.actor_version ?? 1);
+      const serviceName = CadenzaService.serviceRegistry.serviceName;
+      if (!actorName) {
+        throw new Error("actor_name is required for actor session hydration");
+      }
+      if (!actorKey) {
+        throw new Error("actor_key is required for actor session hydration");
+      }
+      if (!Number.isInteger(actorVersion) || actorVersion < 1) {
+        throw new Error("actor_version must be a positive integer");
+      }
+      if (!serviceName) {
+        throw new Error("service_name is not available for actor session hydration");
+      }
+      return {
+        ...ctx,
+        actor_name: actorName,
+        actor_key: actorKey,
+        actor_version: actorVersion,
+        service_name: serviceName,
+        queryData: {
+          filter: {
+            actor_name: actorName,
+            actor_version: actorVersion,
+            actor_key: actorKey,
+            service_name: serviceName,
+            deleted: false
+          },
+          queryMode: "one",
+          sort: {
+            updated: "desc"
+          }
+        }
+      };
+    },
+    "Builds a one-row actor_session_state lookup for lazy actor hydration.",
+    localActorSessionTaskOptions
+  ).then(queryAndValidateActorSessionStateTask).respondsTo(META_ACTOR_SESSION_STATE_HYDRATE_INTENT);
   CadenzaService.createMetaTask(
     "Persist actor session state",
     (ctx) => {
@@ -12548,16 +13345,20 @@ function resolveSyncInsertTask(isCadenzaDBReady, tableName, queryData = {}, opti
         ctx,
         queryData
       );
-      if ((tableName === "signal_registry" || tableName === "directional_task_graph_map") && originalQueryData.data && typeof originalQueryData.data === "object" && !Array.isArray(originalQueryData.data) && Object.keys(originalQueryData.data).length === 0) {
-        console.warn(
-          "[CADENZA_SYNC_EMPTY_INSERT]",
-          {
-            tableName,
-            queryData: originalQueryData,
-            ctx,
-            joinedContexts: Array.isArray(ctx.joinedContexts) ? ctx.joinedContexts : []
-          }
-        );
+      const hasEmptyObjectData = originalQueryData.data && typeof originalQueryData.data === "object" && !Array.isArray(originalQueryData.data) && Object.keys(originalQueryData.data).length === 0;
+      const hasMissingData = originalQueryData.data === void 0;
+      if ((tableName === "task" || tableName === "signal_registry" || tableName === "directional_task_graph_map") && (hasEmptyObjectData || hasMissingData)) {
+        console.warn("[CADENZA_SYNC_EMPTY_INSERT]", {
+          tableName,
+          hasMissingData,
+          hasEmptyObjectData,
+          taskName: typeof ctx.__taskName === "string" ? ctx.__taskName : void 0,
+          reason: typeof ctx.__reason === "string" ? ctx.__reason : void 0,
+          syncSourceServiceName: typeof ctx.__syncSourceServiceName === "string" ? ctx.__syncSourceServiceName : void 0,
+          queryData: originalQueryData,
+          ctx,
+          joinedContexts: Array.isArray(ctx.joinedContexts) ? ctx.joinedContexts : []
+        });
       }
       return buildSyncExecutionEnvelope(
         ctx,
@@ -12648,7 +13449,7 @@ function isBootstrapLocalOnlyActorName(actorName) {
   return BOOTSTRAP_LOCAL_ONLY_ACTOR_NAMES.has(actorName);
 }
 function isBootstrapLocalOnlySignal(signalName) {
-  return signalName.startsWith("meta.") || signalName === "meta.service_registry.insert_execution_requested" || signalName === "meta.service_registry.routeable_transport_missing" || signalName === "meta.signal_broker.added" || signalName === "meta.rest.handshake" || signalName === "meta.rest.delegation_target_not_found" || signalName === "meta.socket.handshake" || signalName === "meta.socket.delegation_target_not_found" || signalName === "meta.fetch.handshake_complete" || signalName === "sub_meta.signal_broker.new_trace" || signalName.startsWith("meta.task.") || signalName.startsWith("meta.sync_controller.") || isLocalServiceReadySignal(signalName);
+  return signalName.startsWith("meta.") || signalName.startsWith("global.meta.") || signalName === "meta.service_registry.insert_execution_requested" || signalName === "meta.service_registry.routeable_transport_missing" || signalName === "meta.signal_broker.added" || signalName === "meta.rest.handshake" || signalName === "meta.rest.delegation_target_not_found" || signalName === "meta.socket.handshake" || signalName === "meta.socket.delegation_target_not_found" || signalName === "meta.fetch.handshake_complete" || signalName === "sub_meta.signal_broker.new_trace" || signalName.startsWith("meta.task.") || signalName.startsWith("meta.sync_controller.") || isLocalServiceReadySignal(signalName);
 }
 function hasNonZeroPending(summary) {
   return Object.values(summary).some((value) => Number(value) > 0);
@@ -12876,6 +13677,12 @@ function resolveLocalRoutineFromSyncContext(ctx) {
   );
   return routineName ? CadenzaService.getRoutine(routineName) : void 0;
 }
+function shouldTrackDirectionalTaskMapForBootstrap(predecessorTask, nextTask) {
+  if (!predecessorTask || !nextTask) {
+    return false;
+  }
+  return predecessorTask.isMeta !== true && predecessorTask.isSubMeta !== true && nextTask.isMeta !== true && nextTask.isSubMeta !== true;
+}
 function resolveSignalNameFromSyncContext(ctx) {
   const candidateSignalNames = [
     ctx.signalName,
@@ -13952,7 +14759,7 @@ var GraphSyncController = class _GraphSyncController {
           return;
         }
         for (const t of task.nextTasks) {
-          if (task.taskMapRegistration.has(t.name) || t.hidden || !t.register || !t.registered) {
+          if (task.taskMapRegistration.has(t.name) || t.hidden || !t.register || !t.registered || !shouldTrackDirectionalTaskMapForBootstrap(task, t)) {
             continue;
           }
           const serviceName2 = resolveSyncServiceName(t);
@@ -14020,7 +14827,7 @@ var GraphSyncController = class _GraphSyncController {
         return false;
       }
       for (const nextTask of task.nextTasks) {
-        if (task.taskMapRegistration.has(nextTask.name) || nextTask.isHidden || !nextTask.register || !nextTask.registered) {
+        if (task.taskMapRegistration.has(nextTask.name) || nextTask.isHidden || !nextTask.register || !nextTask.registered || !shouldTrackDirectionalTaskMapForBootstrap(task, nextTask)) {
           continue;
         }
         if (resolveSyncServiceName(nextTask)) {
@@ -16310,10 +17117,23 @@ function resolveInquiryFailureError(inquiry, value, depth = 3, seen = /* @__PURE
   }
   return `Inquiry '${inquiry}' did not complete successfully`;
 }
+function normalizePositiveInteger(value, fallback) {
+  const normalized = Number(value);
+  return Number.isInteger(normalized) && normalized > 0 ? normalized : fallback;
+}
 var DEFAULT_DEPUTY_TASK_CONCURRENCY = 50;
 var DEFAULT_DEPUTY_TASK_TIMEOUT_MS = 12e4;
 var DEFAULT_DATABASE_PROXY_TASK_CONCURRENCY = 50;
 var DEFAULT_DATABASE_PROXY_TASK_TIMEOUT_MS = 12e4;
+var SERVICE_MANIFEST_PUBLICATION_ORDER = [
+  "routing_capability",
+  "business_structural",
+  "local_meta_structural"
+];
+function getServiceManifestPublicationLayerRank(layer) {
+  const index = SERVICE_MANIFEST_PUBLICATION_ORDER.indexOf(layer);
+  return index >= 0 ? index : SERVICE_MANIFEST_PUBLICATION_ORDER.length - 1;
+}
 var CadenzaService = class {
   static unregisterGracefulShutdownHandlers() {
     for (const cleanup of this.shutdownHandlerCleanup) {
@@ -16440,7 +17260,15 @@ var CadenzaService = class {
     this.replayRegisteredTaskSignalObservations();
     this.replayRegisteredTaskIntentAssociations();
   }
-  static requestServiceManifestPublication(reason, immediate = false) {
+  static normalizeServiceManifestPublicationLayer(value, fallback = "business_structural") {
+    return value === "routing_capability" || value === "business_structural" || value === "local_meta_structural" ? value : fallback;
+  }
+  static mergeServiceManifestPublicationRequest(reason, targetLayer) {
+    this.serviceManifestPublicationPendingReason = reason;
+    const currentTargetLayer = this.serviceManifestPublicationPendingLayer ?? "routing_capability";
+    this.serviceManifestPublicationPendingLayer = getServiceManifestPublicationLayerRank(targetLayer) >= getServiceManifestPublicationLayerRank(currentTargetLayer) ? targetLayer : currentTargetLayer;
+  }
+  static requestServiceManifestPublication(reason, immediate = false, targetLayer = "business_structural") {
     if (!this.serviceRegistry.serviceName || !this.serviceRegistry.serviceInstanceId) {
       return;
     }
@@ -16448,7 +17276,8 @@ var CadenzaService = class {
     const payload = {
       __reason: reason,
       __serviceName: this.serviceRegistry.serviceName,
-      __serviceInstanceId: this.serviceRegistry.serviceInstanceId
+      __serviceInstanceId: this.serviceRegistry.serviceInstanceId,
+      __publicationLayer: targetLayer
     };
     if (immediate) {
       this.emit(signalName, payload);
@@ -16456,32 +17285,53 @@ var CadenzaService = class {
     }
     this.debounce(signalName, payload, 100);
   }
-  static scheduleServiceManifestPublicationRetry(reason) {
+  static scheduleServiceManifestPublicationRetry(reason, targetLayer = "business_structural") {
     if (!this.serviceRegistry.serviceName || !this.serviceRegistry.serviceInstanceId) {
       return;
     }
     setTimeout(() => {
-      this.requestServiceManifestPublication(reason, false);
+      this.requestServiceManifestPublication(reason, false, targetLayer);
     }, 1e3);
   }
-  static async publishServiceManifestIfNeeded(reason) {
+  static async publishServiceManifestIfNeeded(reason, targetLayer = "business_structural") {
     if (!this.serviceRegistry.connectsToCadenzaDB || !this.serviceRegistry.serviceName || !this.serviceRegistry.serviceInstanceId) {
       return false;
     }
     const publishReason = typeof reason === "string" && reason.trim().length > 0 ? reason.trim() : "service_manifest_publish";
+    const publishTargetLayer = this.normalizeServiceManifestPublicationLayer(
+      targetLayer
+    );
     if (this.serviceManifestPublicationInFlight) {
-      this.serviceManifestPublicationPendingReason = publishReason;
+      this.mergeServiceManifestPublicationRequest(
+        publishReason,
+        publishTargetLayer
+      );
       return false;
     }
-    const snapshot = buildServiceManifestSnapshot({
-      serviceName: this.serviceRegistry.serviceName,
-      serviceInstanceId: this.serviceRegistry.serviceInstanceId,
-      revision: this.serviceManifestRevision + 1,
-      publishedAt: (/* @__PURE__ */ new Date()).toISOString()
+    const publicationPlan = SERVICE_MANIFEST_PUBLICATION_ORDER.filter(
+      (layer) => getServiceManifestPublicationLayerRank(layer) <= getServiceManifestPublicationLayerRank(publishTargetLayer)
+    ).map((layer) => {
+      const snapshot2 = buildServiceManifestSnapshot({
+        serviceName: this.serviceRegistry.serviceName,
+        serviceInstanceId: this.serviceRegistry.serviceInstanceId,
+        revision: this.serviceManifestRevision + 1,
+        publishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        publicationLayer: layer
+      });
+      return {
+        layer,
+        snapshot: snapshot2,
+        changed: this.lastPublishedServiceManifestHashes[layer] !== snapshot2.manifestHash
+      };
     });
-    if (this.lastPublishedServiceManifestHash && this.lastPublishedServiceManifestHash === snapshot.manifestHash) {
+    const nextPublication = publicationPlan.find((entry) => entry.changed);
+    if (!nextPublication) {
       return false;
     }
+    const { layer: publicationLayer, snapshot } = nextPublication;
+    const hasPendingFollowupLayer = publicationPlan.some(
+      (entry) => entry.changed && getServiceManifestPublicationLayerRank(entry.layer) > getServiceManifestPublicationLayerRank(publicationLayer)
+    );
     this.serviceManifestPublicationInFlight = true;
     try {
       this.serviceRegistry.ensureBootstrapAuthorityControlPlaneForInquiry(
@@ -16489,7 +17339,10 @@ var CadenzaService = class {
         snapshot
       );
       if (!this.serviceRegistry.hasAuthorityBootstrapHandshakeEstablished()) {
-        this.scheduleServiceManifestPublicationRetry(publishReason);
+        this.scheduleServiceManifestPublicationRetry(
+          publishReason,
+          publishTargetLayer
+        );
         return false;
       }
       await this.inquire(AUTHORITY_SERVICE_MANIFEST_REPORT_INTENT, snapshot, {
@@ -16497,32 +17350,48 @@ var CadenzaService = class {
         requireComplete: true
       });
       this.serviceManifestRevision = snapshot.revision;
-      this.lastPublishedServiceManifestHash = snapshot.manifestHash;
+      this.lastPublishedServiceManifestHashes[publicationLayer] = snapshot.manifestHash;
+      if (hasPendingFollowupLayer) {
+        this.mergeServiceManifestPublicationRequest(
+          publishReason,
+          publishTargetLayer
+        );
+      }
       return {
         serviceManifest: snapshot,
-        published: true
+        published: true,
+        publicationLayer
       };
     } catch (error) {
       this.log("Service manifest publication failed. Scheduling retry.", {
         serviceName: this.serviceRegistry.serviceName,
         serviceInstanceId: this.serviceRegistry.serviceInstanceId,
         reason: publishReason,
+        publicationLayer,
         error: resolveInquiryFailureError(
           AUTHORITY_SERVICE_MANIFEST_REPORT_INTENT,
           error
         ),
         inquiryMeta: error && typeof error === "object" && "__inquiryMeta" in error ? error.__inquiryMeta : null
       });
-      this.scheduleServiceManifestPublicationRetry(publishReason);
+      this.scheduleServiceManifestPublicationRetry(
+        publishReason,
+        publishTargetLayer
+      );
       return false;
     } finally {
       this.serviceManifestPublicationInFlight = false;
-      if (this.serviceManifestPublicationPendingReason) {
+      if (this.serviceManifestPublicationPendingReason && this.serviceManifestPublicationPendingLayer) {
         const pendingReason = this.serviceManifestPublicationPendingReason;
+        const pendingLayer = this.serviceManifestPublicationPendingLayer;
         this.serviceManifestPublicationPendingReason = null;
+        this.serviceManifestPublicationPendingLayer = null;
         this.debounce(
           "meta.service_manifest.publish_requested",
-          { __reason: pendingReason },
+          {
+            __reason: pendingReason,
+            __publicationLayer: pendingLayer
+          },
           100
         );
       }
@@ -16535,9 +17404,13 @@ var CadenzaService = class {
     this.createMetaTask(
       "Publish service manifest",
       async (ctx) => this.publishServiceManifestIfNeeded(
-        typeof ctx.__reason === "string" && ctx.__reason.trim().length > 0 ? ctx.__reason.trim() : "service_manifest_publish"
+        typeof ctx.__reason === "string" && ctx.__reason.trim().length > 0 ? ctx.__reason.trim() : "service_manifest_publish",
+        this.normalizeServiceManifestPublicationLayer(
+          ctx.__publicationLayer,
+          "business_structural"
+        )
       ),
-      "Publishes a full static manifest snapshot to authority when the manifest hash changes.",
+      "Publishes staged static manifest snapshots to authority when the manifest hash changes.",
       {
         register: false,
         isHidden: true
@@ -16547,13 +17420,18 @@ var CadenzaService = class {
       "Request manifest publication after structural change",
       (ctx) => {
         const reason = typeof ctx.signal === "string" && ctx.signal.trim().length > 0 ? ctx.signal : typeof ctx.__reason === "string" && ctx.__reason.trim().length > 0 ? ctx.__reason : "manifest_structural_update";
+        const targetLayer = reason === "meta.service_registry.instance_inserted" ? "business_structural" : this.normalizeServiceManifestPublicationLayer(
+          ctx.__publicationLayer,
+          "business_structural"
+        );
         this.requestServiceManifestPublication(
           reason,
-          reason === "meta.service_registry.instance_inserted"
+          reason === "meta.service_registry.instance_inserted",
+          targetLayer
         );
         return true;
       },
-      "Requests a manifest publication when a static service primitive changes.",
+      "Requests staged manifest publication when a static service primitive changes.",
       {
         register: false,
         isHidden: true
@@ -17808,10 +18686,28 @@ var CadenzaService = class {
       __isFrontend: isFrontend,
       __declaredTransports: declaredTransports
     };
+    let bootstrapServiceCreationRequested = false;
     if (options.cadenzaDB?.connect) {
-      this.createEphemeralMetaTask("Create service", async (context, emit2) => {
-        emit2("meta.create_service_requested", initContext);
-      }).doOn("meta.fetch.handshake_complete");
+      this.createMetaTask(
+        "Create service",
+        async (context, emit2) => {
+          const handshakeServiceName = String(context?.serviceName ?? "").trim();
+          if (handshakeServiceName !== "CadenzaDB") {
+            return false;
+          }
+          if (bootstrapServiceCreationRequested) {
+            return false;
+          }
+          bootstrapServiceCreationRequested = true;
+          emit2("meta.create_service_requested", initContext);
+          return true;
+        },
+        "Requests local service creation only once after the initial authority bootstrap handshake completes.",
+        {
+          register: false,
+          isHidden: true
+        }
+      ).doOn("meta.fetch.handshake_complete");
     } else {
       this.emit("meta.create_service_requested", initContext);
       this.createMetaTask("Create signal transmission for sync", (ctx, emit2) => {
@@ -17824,10 +18720,33 @@ var CadenzaService = class {
         );
       }).doOn("meta.rest.handshake", "meta.socket.handshake");
     }
+    let serviceSetupCompletedHandled = false;
     this.createMetaTask("Handle service setup completion", (ctx, emit2) => {
+      if (serviceSetupCompletedHandled) {
+        return false;
+      }
+      const insertedServiceInstanceId = String(
+        ctx?.serviceInstanceId ?? ctx?.service_instance_id ?? ctx?.serviceInstance?.uuid ?? ctx?.serviceInstance?.serviceInstanceId ?? ""
+      ).trim();
+      const insertedServiceName = String(
+        ctx?.serviceName ?? ctx?.service_name ?? ctx?.serviceInstance?.serviceName ?? ctx?.serviceInstance?.service_name ?? ""
+      ).trim();
+      if (!insertedServiceInstanceId && !insertedServiceName) {
+        return false;
+      }
+      if (insertedServiceInstanceId && insertedServiceInstanceId !== serviceId) {
+        return false;
+      }
+      if (!insertedServiceInstanceId && insertedServiceName && insertedServiceName !== serviceName) {
+        return false;
+      }
+      serviceSetupCompletedHandled = true;
       if (options.cadenzaDB?.connect) {
         this.serviceRegistry.bootstrapFullSync(emit2, ctx, "service_setup_completed");
-        void this.publishServiceManifestIfNeeded("service_setup_completed");
+        void this.publishServiceManifestIfNeeded(
+          "service_setup_completed",
+          "business_structural"
+        );
       }
       if (isFrontend) {
         registerActorSessionPersistenceTasks();
@@ -17882,7 +18801,11 @@ var CadenzaService = class {
       );
     }
     this.serviceCreated = true;
-    this.requestServiceManifestPublication("service_created", true);
+    this.requestServiceManifestPublication(
+      "service_created",
+      true,
+      "routing_capability"
+    );
   }
   /**
    * Creates a Cadenza metadata service with the specified name, description, and options.
@@ -18143,11 +19066,84 @@ var CadenzaService = class {
   }
   static createActor(spec, options = {}) {
     this.bootstrap();
-    return Cadenza.createActor(spec, options);
+    return Cadenza.createActor(
+      spec,
+      this.withActorSessionHydration(
+        spec,
+        options
+      )
+    );
   }
   static createActorFromDefinition(definition, options = {}) {
     this.bootstrap();
-    return Cadenza.createActorFromDefinition(definition, options);
+    return Cadenza.createActorFromDefinition(
+      definition,
+      this.withActorSessionHydration(
+        {
+          name: definition.name,
+          description: definition.description,
+          defaultKey: definition.defaultKey,
+          kind: definition.kind,
+          loadPolicy: definition.loadPolicy,
+          writeContract: definition.writeContract,
+          consistencyProfile: definition.consistencyProfile,
+          retry: definition.retry,
+          idempotency: definition.idempotency,
+          session: definition.session,
+          runtimeReadGuard: definition.runtimeReadGuard,
+          key: definition.key,
+          state: definition.state,
+          taskBindings: definition.tasks,
+          initState: definition.state?.durable?.initState ?? definition.state?.durable?.initialState
+        },
+        options
+      )
+    );
+  }
+  static withActorSessionHydration(spec, options) {
+    if (options.hydrateDurableState || spec.session?.persistDurableState !== true) {
+      return options;
+    }
+    const actorName = String(spec.name ?? "").trim();
+    const actorVersion = 1;
+    const timeoutMs = normalizePositiveInteger(
+      spec.session?.persistenceTimeoutMs,
+      5e3
+    );
+    return {
+      ...options,
+      hydrateDurableState: async (actorKey) => {
+        registerActorSessionPersistenceTasks();
+        const response = await Cadenza.inquire(
+          META_ACTOR_SESSION_STATE_HYDRATE_INTENT,
+          {
+            actor_name: actorName,
+            actor_version: actorVersion,
+            actor_key: actorKey
+          },
+          {
+            timeout: timeoutMs,
+            requireComplete: true,
+            rejectOnTimeout: true
+          }
+        );
+        if (!response || typeof response !== "object" || response.__success !== true) {
+          throw new Error(
+            resolveInquiryFailureError(
+              META_ACTOR_SESSION_STATE_HYDRATE_INTENT,
+              response
+            )
+          );
+        }
+        if (response.hydrated !== true) {
+          return null;
+        }
+        return {
+          durableState: response.durable_state,
+          durableVersion: Number(response.durable_version)
+        };
+      }
+    };
   }
   /**
    * Creates and registers a new task with the provided name, function, and optional details.
@@ -18565,6 +19561,11 @@ var CadenzaService = class {
     this.warnedInvalidMetaIntentResponderKeys = /* @__PURE__ */ new Set();
     this.hydratedInquiryResults = /* @__PURE__ */ new Map();
     this.frontendSyncScheduled = false;
+    this.serviceManifestRevision = 0;
+    this.lastPublishedServiceManifestHashes = {};
+    this.serviceManifestPublicationInFlight = false;
+    this.serviceManifestPublicationPendingReason = null;
+    this.serviceManifestPublicationPendingLayer = null;
     resetBrowserRuntimeActorHandles();
   }
 };
@@ -18578,9 +19579,10 @@ CadenzaService.warnedInvalidMetaIntentResponderKeys = /* @__PURE__ */ new Set();
 CadenzaService.hydratedInquiryResults = /* @__PURE__ */ new Map();
 CadenzaService.frontendSyncScheduled = false;
 CadenzaService.serviceManifestRevision = 0;
-CadenzaService.lastPublishedServiceManifestHash = null;
+CadenzaService.lastPublishedServiceManifestHashes = {};
 CadenzaService.serviceManifestPublicationInFlight = false;
 CadenzaService.serviceManifestPublicationPendingReason = null;
+CadenzaService.serviceManifestPublicationPendingLayer = null;
 CadenzaService.shutdownHandlersRegistered = false;
 CadenzaService.shutdownInFlight = false;
 CadenzaService.shutdownHandlerCleanup = [];
@@ -18614,6 +19616,17 @@ function normalizeArrayResponse(value, keys) {
   if (Array.isArray(value?.data)) {
     return value.data;
   }
+  const joinedContexts = Array.isArray(value?.joinedContexts) ? value.joinedContexts : [];
+  for (let index = joinedContexts.length - 1; index >= 0; index -= 1) {
+    const nested = joinedContexts[index];
+    if (!nested || typeof nested !== "object") {
+      continue;
+    }
+    const rows = normalizeArrayResponse(nested, keys);
+    if (rows.length > 0) {
+      return rows;
+    }
+  }
   return [];
 }
 function buildQueryResponseKeys(tableName) {