@cadenza.io/service 2.19.1 → 2.20.1

package/dist/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);
   }
 };
@@ -578,6 +658,26 @@ var AUTHORITY_SYNC_DEBUG_TASK_NAMES = /* @__PURE__ */ new Set([
 ]);
 var AUTHORITY_SYNC_DEBUG_ROUTINE_NAMES = /* @__PURE__ */ new Set(["Sync services"]);
 var INTENT_MAP_DEBUG_ENABLED = process.env.CADENZA_INTENT_MAP_DEBUG === "1" || process.env.CADENZA_INTENT_MAP_DEBUG === "true";
+function normalizeQueryResultValue(value) {
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => normalizeQueryResultValue(entry));
+  }
+  if (value && typeof value === "object") {
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype === Object.prototype || prototype === null) {
+      return Object.fromEntries(
+        Object.entries(value).map(([key, nestedValue]) => [
+          key,
+          normalizeQueryResultValue(nestedValue)
+        ])
+      );
+    }
+  }
+  return value;
+}
 var POSTGRES_SETUP_DEBUG_ENABLED = process.env.CADENZA_POSTGRES_SETUP_DEBUG === "1" || process.env.CADENZA_POSTGRES_SETUP_DEBUG === "true";
 var ACTOR_SESSION_TRACE_ENABLED2 = process.env.CADENZA_ACTOR_SESSION_TRACE === "1" || process.env.CADENZA_ACTOR_SESSION_TRACE === "true";
 var ACTOR_SESSION_TRACE_LIMIT = 20;
@@ -875,14 +975,14 @@ function errorMessage(error) {
   }
   return String(error);
 }
-function isPlainObject(value) {
+function isPlainObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function stableStringify(value) {
   if (Array.isArray(value)) {
     return `[${value.map((item) => stableStringify(item)).join(",")}]`;
   }
-  if (isPlainObject(value)) {
+  if (isPlainObject2(value)) {
     return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(",")}}`;
   }
   return JSON.stringify(value);
@@ -998,7 +1098,23 @@ function resolveGeneratedTaskTag(tableName, actorToken, context, operation) {
   if (operation === "insert") {
     return `insert:${actorToken}:${tableName}`;
   }
-  return context?.__metadata?.__executionTraceId ?? context?.__executionTraceId ?? "default";
+  const traceScopedTag = context?.__metadata?.__executionTraceId ?? context?.__executionTraceId ?? context?.__metadata?.__deputyExecId ?? context?.__deputyExecId ?? context?.__metadata?.__inquiryId ?? context?.__inquiryId ?? context?.__metadata?.__routineExecId ?? context?.__routineExecId ?? context?.__metadata?.__localRoutineExecId ?? context?.__localRoutineExecId;
+  if (typeof traceScopedTag === "string" && traceScopedTag.length > 0) {
+    return traceScopedTag;
+  }
+  const queryScope = {
+    queryData: context?.queryData,
+    filter: context?.filter,
+    fields: context?.fields,
+    joins: context?.joins,
+    sort: context?.sort,
+    limit: context?.limit,
+    offset: context?.offset,
+    queryMode: context?.queryMode,
+    aggregates: context?.aggregates,
+    groupBy: context?.groupBy
+  };
+  return `read:${actorToken}:${tableName}:${stableStringify(queryScope)}`;
 }
 function resolveExecutionObservabilitySafetyPolicyForTable(basePolicy, tableName) {
   if (!EXECUTION_OBSERVABILITY_TABLES.has(tableName)) {
@@ -1080,6 +1196,44 @@ function mergeTriggerQueryData(context, triggerQueryData) {
     ...triggerQueryData
   };
 }
+function isNonEmptyPlainObject(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length > 0;
+}
+function isMissingInsertData(data) {
+  return !data || Array.isArray(data) && data.length === 0 || typeof data === "object" && !Array.isArray(data) && Object.keys(data).length === 0;
+}
+function resolveActorSessionDelegationSnapshot(context) {
+  const direct = context.__delegationRequestContext && typeof context.__delegationRequestContext === "object" ? context.__delegationRequestContext : null;
+  if (direct) {
+    return direct;
+  }
+  const metadata = context.__metadata && typeof context.__metadata === "object" ? context.__metadata : null;
+  const nested = metadata?.__delegationRequestContext && typeof metadata.__delegationRequestContext === "object" ? metadata.__delegationRequestContext : null;
+  return nested;
+}
+function recoverActorSessionInsertPayload(context, payload) {
+  if (!isMissingInsertData(payload.data)) {
+    return payload;
+  }
+  const snapshot = resolveActorSessionDelegationSnapshot(context);
+  if (!snapshot) {
+    return payload;
+  }
+  const snapshotQueryData = snapshot.queryData && typeof snapshot.queryData === "object" ? { ...snapshot.queryData } : {};
+  const snapshotData = isNonEmptyPlainObject(snapshotQueryData.data) ? snapshotQueryData.data : isNonEmptyPlainObject(snapshot.data) ? snapshot.data : null;
+  if (!snapshotData) {
+    return payload;
+  }
+  const recoveredPayload = {
+    ...snapshotQueryData,
+    ...payload,
+    data: snapshotData
+  };
+  if (recoveredPayload.onConflict === void 0 && snapshotQueryData.onConflict) {
+    recoveredPayload.onConflict = snapshotQueryData.onConflict;
+  }
+  return recoveredPayload;
+}
 function resolveOperationPayload(context) {
   const queryData = typeof context.queryData === "object" && context.queryData ? context.queryData : {};
   return mergeTriggerQueryData(context, queryData);
@@ -1807,6 +1961,23 @@ var DatabaseController = class _DatabaseController {
   async insertFunction(registration, tableName, context) {
     const { data, transaction = true, fields = [], onConflict } = context;
     if (!data || Array.isArray(data) && data.length === 0) {
+      if (tableName === "actor_session_state") {
+        const rawContext = context;
+        const rawMetadata = rawContext.__metadata && typeof rawContext.__metadata === "object" ? rawContext.__metadata : void 0;
+        console.warn("[CADENZA_ACTOR_SESSION_EMPTY_INSERT]", {
+          tableName,
+          contextKeys: Object.keys(context ?? {}),
+          queryDataKeys: [],
+          hasDelegationSnapshot: rawContext.__delegationRequestContext !== void 0 || rawMetadata?.__delegationRequestContext !== void 0,
+          localTaskName: typeof rawContext.__localTaskName === "string" ? rawContext.__localTaskName : void 0,
+          remoteRoutineName: typeof rawContext.__remoteRoutineName === "string" ? rawContext.__remoteRoutineName : void 0,
+          serviceName: typeof rawContext.__serviceName === "string" ? rawContext.__serviceName : void 0,
+          actorName: typeof rawContext.actor_name === "string" ? rawContext.actor_name : void 0,
+          actorKey: typeof rawContext.actor_key === "string" ? rawContext.actor_key : void 0,
+          durableVersion: rawContext.durable_version,
+          metadata: rawMetadata
+        });
+      }
       return {
         rowCount: 0,
         errored: true,
@@ -2876,9 +3047,18 @@ var DatabaseController = class _DatabaseController {
             }
           }
         }
-        const operationPayload = resolveOperationPayload(context);
+        const initialOperationPayload = resolveOperationPayload(context);
+        let operationPayload = initialOperationPayload;
+        if (tableName === "actor_session_state" && op === "insert") {
+          operationPayload = recoverActorSessionInsertPayload(
+            context,
+            operationPayload
+          );
+        }
         const actorSessionInsertData = operationPayload.data;
-        const actorSessionInsertMissingData = !actorSessionInsertData || Array.isArray(actorSessionInsertData) && actorSessionInsertData.length === 0 || typeof actorSessionInsertData === "object" && !Array.isArray(actorSessionInsertData) && Object.keys(actorSessionInsertData).length === 0;
+        const actorSessionInsertMissingData = isMissingInsertData(
+          actorSessionInsertData
+        );
         if (tableName === "actor_session_state" && op === "insert" && actorSessionInsertMissingData) {
           logActorSessionTrace("empty_insert_payload", {
             taskName,
@@ -2894,7 +3074,10 @@ var DatabaseController = class _DatabaseController {
             payloadDataType: actorSessionInsertData === null ? "null" : Array.isArray(actorSessionInsertData) ? "array" : typeof actorSessionInsertData,
             payloadDataKeys: actorSessionInsertData && typeof actorSessionInsertData === "object" && !Array.isArray(actorSessionInsertData) ? Object.keys(actorSessionInsertData) : [],
             queryDataKeys: context.queryData && typeof context.queryData === "object" && !Array.isArray(context.queryData) ? Object.keys(context.queryData) : [],
-            rootKeys: Object.keys(context ?? {}).slice(0, 24)
+            rootKeys: Object.keys(context ?? {}).slice(0, 24),
+            initialPayloadMissingData: isMissingInsertData(
+              initialOperationPayload.data
+            )
           });
         }
         const shouldDebugAuthoritySync = shouldDebugAuthoritySyncPayload(
@@ -3189,7 +3372,7 @@ var DatabaseController = class _DatabaseController {
     return rows.map((row) => {
       const camelCasedRow = {};
       for (const [key, value] of Object.entries(row)) {
-        camelCasedRow[camelCase(key)] = value;
+        camelCasedRow[camelCase(key)] = normalizeQueryResultValue(value);
       }
       return camelCasedRow;
     });
@@ -3624,14 +3807,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 isPlainObject2(value) {
+function isPlainObject3(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 (isPlainObject2(left) && isPlainObject2(right)) {
+  if (isPlainObject3(left) && isPlainObject3(right)) {
     const merged = { ...left };
     const keys = Array.from(/* @__PURE__ */ new Set([...Object.keys(left), ...Object.keys(right)])).sort();
     for (const key of keys) {
@@ -4453,6 +4636,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),
@@ -4582,6 +4766,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") {
@@ -4726,14 +4911,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(
@@ -4881,41 +5100,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,
@@ -5053,7 +5616,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) {
@@ -5071,7 +5634,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) {
@@ -5098,8 +5662,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;
@@ -5155,7 +5825,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;
   }
@@ -5185,6 +5856,7 @@ function normalizeServiceRegistryInsertResult(tableName, ctx, queryData, rawResu
     ).trim();
     if (resolvedServiceName) {
       result.__serviceName = resolvedServiceName;
+      result.serviceName = resolvedServiceName;
     }
   }
   const resolvedLocalServiceInstanceId = String(
@@ -5193,6 +5865,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 ?? ""
@@ -5292,9 +5976,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,
@@ -5307,9 +5997,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(
@@ -5481,6 +6169,7 @@ function resolveServiceRegistryInsertTask(tableName, queryData = {}, options = {
       if (bootstrapAuthorityInsertSpec) {
         const sanitizedContext = sanitizeServiceRegistryInsertExecutionContext(ctx);
         const nextQueryData = buildServiceRegistryInsertQueryData(
+          tableName,
           sanitizedContext,
           queryData
         );
@@ -5915,6 +6604,9 @@ var ServiceRegistry = class _ServiceRegistry {
           ctx.deleted ?? ctx.serviceInstance?.deleted ?? ctx.data?.deleted
         );
         if (uuid10 === this.serviceInstanceId) return;
+        if (serviceName === this.serviceName) {
+          return false;
+        }
         if (deleted) {
           const existingInstance = this.instances.get(serviceName)?.find((instance) => instance.uuid === uuid10);
           const indexToDelete = this.instances.get(serviceName)?.findIndex((i) => i.uuid === uuid10) ?? -1;
@@ -6001,9 +6693,6 @@ var ServiceRegistry = class _ServiceRegistry {
             emit2
           );
         }
-        if (this.serviceName === serviceName) {
-          return false;
-        }
         if (trackedInstance?.isFrontend) {
           return true;
         }
@@ -6057,6 +6746,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(
@@ -8483,6 +9175,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(
@@ -8517,6 +9211,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;
@@ -8549,7 +9245,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((uuid10) => uuid10.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
     );
@@ -8611,47 +9336,51 @@ var ServiceRegistry = class _ServiceRegistry {
     );
     pushUnique(
       explodedManifest.actorTaskMaps,
-      actorTaskMaps,
-      seenActorTaskMaps,
-      (row) => `${String(row.actor_name ?? "").trim()}|${String(row.actor_version ?? 1).trim()}|${String(
-        row.service_name ?? ""
-      ).trim()}|${String(row.task_name ?? "").trim()}|${String(
-        row.task_version ?? 1
-      ).trim()}`
-    );
-    pushUnique(
-      explodedManifest.taskToRoutineMaps,
-      taskToRoutineMaps,
-      seenTaskToRoutineMaps,
-      (row) => `${String(row.routine_name ?? "").trim()}|${String(row.routine_version ?? 1).trim()}|${String(
-        row.service_name ?? ""
-      ).trim()}|${String(row.task_name ?? "").trim()}|${String(
-        row.task_version ?? 1
-      ).trim()}`
-    );
-    pushUnique(
-      explodedManifest.signalToTaskMaps,
-      signalToTaskMaps,
-      seenSignalMaps,
-      (row) => `${String(row.signal_name ?? "").trim()}|${String(
+      actorTaskMaps,
+      seenActorTaskMaps,
+      (row) => `${String(row.actor_name ?? "").trim()}|${String(row.actor_version ?? 1).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(
+      explodedManifest.taskToRoutineMaps,
+      taskToRoutineMaps,
+      seenTaskToRoutineMaps,
+      (row) => `${String(row.routine_name ?? "").trim()}|${String(row.routine_version ?? 1).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,
@@ -8661,8 +9390,8 @@ var ServiceRegistry = class _ServiceRegistry {
       directionalTaskMaps,
       actorTaskMaps,
       taskToRoutineMaps,
-      signalToTaskMaps,
-      intentToTaskMaps
+      signalToTaskMaps: filteredSignalToTaskMaps,
+      intentToTaskMaps: filteredIntentToTaskMaps
     };
   }
   buildRemoteIntentDeputyKey(map) {
@@ -9091,10 +9820,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,
@@ -9108,7 +9838,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
@@ -9126,22 +9856,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
       };
@@ -9251,16 +9981,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,
@@ -9268,7 +10017,9 @@ var ServiceRegistry = class _ServiceRegistry {
           ...this.collectBootstrapFullSyncPayload({
             serviceInstances,
             serviceInstanceTransports,
-            serviceManifests
+            serviceManifests,
+            signalToTaskMaps,
+            intentToTaskMaps
           })
         };
       },
@@ -12357,6 +13108,41 @@ var TRACED_INQUIRY_METADATA_SIGNALS = /* @__PURE__ */ new Set([
   "global.meta.graph_metadata.inquiry_updated"
 ]);
 var ACTOR_SESSION_TRACE_ENABLED3 = process.env.CADENZA_ACTOR_SESSION_TRACE === "1" || process.env.CADENZA_ACTOR_SESSION_TRACE === "true";
+function summarizeRequestBodyForLogging(body) {
+  if (typeof body !== "string") {
+    return body;
+  }
+  const summary = {
+    bodyLength: body.length
+  };
+  try {
+    const parsed = JSON.parse(body);
+    const queryData = parsed.queryData && typeof parsed.queryData === "object" ? parsed.queryData : null;
+    const queryDataData = queryData?.data && typeof queryData.data === "object" ? queryData.data : null;
+    const data = parsed.data && typeof parsed.data === "object" ? parsed.data : null;
+    summary.rootKeys = Object.keys(parsed).slice(0, 24);
+    summary.remoteRoutineName = typeof parsed.__remoteRoutineName === "string" ? parsed.__remoteRoutineName : null;
+    summary.serviceName = typeof parsed.__serviceName === "string" ? parsed.__serviceName : null;
+    summary.authorityBootstrapChannel = parsed.__authorityBootstrapChannel === true || parsed.__metadata?.__authorityBootstrapChannel === true;
+    summary.hasData = data !== null;
+    summary.dataKeys = data ? Object.keys(data).slice(0, 24) : [];
+    summary.hasQueryData = queryData !== null;
+    summary.queryDataKeys = queryData ? Object.keys(queryData).slice(0, 24) : [];
+    summary.queryDataDataKeys = queryDataData ? Object.keys(queryDataData).slice(0, 24) : [];
+  } catch {
+    summary.preview = body.slice(0, 240);
+  }
+  return summary;
+}
+function summarizeRequestInitForLogging(requestInit) {
+  if (!requestInit || typeof requestInit !== "object") {
+    return requestInit;
+  }
+  return {
+    ...requestInit,
+    body: summarizeRequestBodyForLogging(requestInit.body)
+  };
+}
 var RestController = class _RestController {
   /**
    * Constructor for initializing the REST server and related configurations.
@@ -12390,16 +13176,17 @@ var RestController = class _RestController {
         const parsedResponse = await this.parseFetchResponse(response);
         return parsedResponse.data;
       } catch (error) {
+        const loggedRequestInit = summarizeRequestInitForLogging(requestInit);
         if (error?.name === "AbortError") {
           CadenzaService.log(
             "Fetch request timed out.",
-            { error, URL: url, requestInit },
+            { error, URL: url, requestInit: loggedRequestInit },
             "warning"
           );
         } else {
           CadenzaService.log(
             "Fetch request error.",
-            { error, URL: url, requestInit },
+            { error, URL: url, requestInit: loggedRequestInit },
             "error"
           );
         }
@@ -12545,7 +13332,7 @@ var RestController = class _RestController {
             return { ...ctx, __app: app };
           },
           "Sets up the Express server according to the security profile"
-        ).attachSignal("meta.service_registry.instance_registration_requested").then(
+        ).then(
           CadenzaService.createMetaTask(
             "Define RestServer",
             (ctx) => {
@@ -12942,32 +13729,40 @@ var RestController = class _RestController {
           serviceName,
           URL2
         );
-        fetchDiagnostics.destroyed = false;
-        fetchDiagnostics.updatedAt = Date.now();
         if (CadenzaService.get(`Send Handshake to ${clientTaskSuffix}`)) {
-          console.error("Fetch client already exists", { URL: URL2, fetchId });
-          CadenzaService.schedule(
-            `meta.fetch.handshake_requested:${fetchId}`,
-            {
-              serviceInstanceId: ctx.serviceInstanceId,
-              serviceName,
-              communicationTypes: ctx.communicationTypes,
-              serviceTransportId: ctx.serviceTransportId,
-              serviceOrigin: URL2,
-              fetchId,
-              routeKey,
-              socketClientId: ctx.socketClientId ?? (routeKey ? buildTransportHandleKey(routeKey, "socket") : void 0),
-              transportProtocols: ctx.transportProtocols,
-              transportProtocol: "rest",
-              handshakeData: ctx.handshakeData
-            },
-            0
-          );
+          const shouldRetryHandshake = ctx.__forceHandshakeRecovery === true || fetchDiagnostics.destroyed === true || (fetchDiagnostics.connected !== true || typeof fetchDiagnostics.lastHandshakeError === "string") && fetchDiagnostics.handshakeInFlight !== true;
+          if (shouldRetryHandshake) {
+            fetchDiagnostics.destroyed = false;
+            fetchDiagnostics.handshakeInFlight = true;
+            fetchDiagnostics.updatedAt = Date.now();
+            console.error("Fetch client already exists", { URL: URL2, fetchId });
+            CadenzaService.debounce(
+              `meta.fetch.handshake_requested:${fetchId}`,
+              {
+                serviceInstanceId: ctx.serviceInstanceId,
+                serviceName,
+                communicationTypes: ctx.communicationTypes,
+                serviceTransportId: ctx.serviceTransportId,
+                serviceOrigin: URL2,
+                fetchId,
+                routeKey,
+                socketClientId: ctx.socketClientId ?? (routeKey ? buildTransportHandleKey(routeKey, "socket") : void 0),
+                transportProtocols: ctx.transportProtocols,
+                transportProtocol: "rest",
+                handshakeData: ctx.handshakeData
+              },
+              50
+            );
+          }
           return true;
         }
+        fetchDiagnostics.destroyed = false;
+        fetchDiagnostics.handshakeInFlight = false;
+        fetchDiagnostics.updatedAt = Date.now();
         const handshakeTask = CadenzaService.createMetaTask(
           `Send Handshake to ${clientTaskSuffix}`,
           async (ctx2, emit2) => {
+            fetchDiagnostics.handshakeInFlight = true;
             try {
               const response = await this.fetchDataWithTimeout(
                 `${URL2}/handshake`,
@@ -12983,6 +13778,7 @@ var RestController = class _RestController {
               if (response.__status !== "success") {
                 const error = response.__error ?? `Failed to connect to service ${serviceName} ${ctx2.serviceInstanceId}`;
                 fetchDiagnostics.connected = false;
+                fetchDiagnostics.handshakeInFlight = false;
                 fetchDiagnostics.lastHandshakeError = error;
                 fetchDiagnostics.updatedAt = Date.now();
                 this.recordFetchClientError(fetchId, serviceName, URL2, error);
@@ -13002,6 +13798,7 @@ var RestController = class _RestController {
               ctx2.serviceInstanceId = response.__serviceInstanceId;
               fetchDiagnostics.connected = true;
               fetchDiagnostics.destroyed = false;
+              fetchDiagnostics.handshakeInFlight = false;
               fetchDiagnostics.lastHandshakeAt = (/* @__PURE__ */ new Date()).toISOString();
               fetchDiagnostics.lastHandshakeError = null;
               fetchDiagnostics.updatedAt = Date.now();
@@ -13030,6 +13827,7 @@ var RestController = class _RestController {
               }
             } catch (e) {
               fetchDiagnostics.connected = false;
+              fetchDiagnostics.handshakeInFlight = false;
               fetchDiagnostics.lastHandshakeError = this.getErrorMessage(e);
               fetchDiagnostics.updatedAt = Date.now();
               this.recordFetchClientError(fetchId, serviceName, URL2, e);
@@ -13062,8 +13860,8 @@ var RestController = class _RestController {
             }
             const routedDelegateCtx = stripTransportSelectionRoutingContext(ctx2);
             const delegateCtx = ensureDelegationContextMetadata(
-              attachDelegationRequestSnapshot(
-                stripDelegationRequestSnapshot(routedDelegateCtx)
+              restoreDelegationRequestSnapshot(
+                attachDelegationRequestSnapshot(routedDelegateCtx)
               )
             );
             const deputyExecId = delegateCtx.__metadata.__deputyExecId;
@@ -13123,13 +13921,11 @@ var RestController = class _RestController {
               fetchDiagnostics.delegationFailures++;
               fetchDiagnostics.updatedAt = Date.now();
               this.recordFetchClientError(fetchId, serviceName, URL2, e);
-              resultContext = {
-                __signalName: "meta.fetch.delegate_failed",
-                __error: `Error: ${e}`,
-                errored: true,
-                ...delegateCtx,
-                ...delegateCtx.__metadata
-              };
+              resultContext = buildDelegationFailureContext(
+                "meta.fetch.delegate_failed",
+                delegateCtx,
+                e
+              );
               routeOutcome = "failure";
               emit2("meta.fetch.delegate_failed", resultContext);
             } finally {
@@ -13295,6 +14091,7 @@ var RestController = class _RestController {
               return false;
             }
             fetchDiagnostics.connected = false;
+            fetchDiagnostics.handshakeInFlight = false;
             fetchDiagnostics.destroyed = true;
             fetchDiagnostics.updatedAt = Date.now();
             CadenzaService.log("Destroying fetch client", { URL: URL2, serviceName });
@@ -13334,7 +14131,15 @@ var RestController = class _RestController {
           const fetchId = String(
             ctx.fetchId ?? ctx.__fetchId ?? (routeKey ? buildTransportHandleKey(routeKey, "rest") : serviceTransportId ?? "")
           );
-          CadenzaService.schedule(`meta.fetch.handshake_requested:${fetchId}`, {
+          const fetchDiagnostics = this.ensureFetchClientDiagnostics(
+            fetchId,
+            String(serviceName ?? ""),
+            String(serviceOrigin ?? "")
+          );
+          if (fetchDiagnostics.handshakeInFlight !== true) {
+            fetchDiagnostics.handshakeInFlight = true;
+          }
+          CadenzaService.debounce(`meta.fetch.handshake_requested:${fetchId}`, {
             serviceInstanceId,
             serviceName,
             communicationTypes,
@@ -13350,7 +14155,7 @@ var RestController = class _RestController {
               serviceName: CadenzaService.serviceRegistry.serviceName
               // JWT token...
             }
-          }, 0);
+          }, 50);
           return true;
         },
         "Prepares handshake"
@@ -13404,6 +14209,7 @@ var RestController = class _RestController {
         serviceName,
         url,
         connected: false,
+        handshakeInFlight: false,
         destroyed: false,
         lastHandshakeAt: null,
         lastHandshakeError: null,
@@ -14841,8 +15647,8 @@ var SocketController = class _SocketController {
               }
               const routedDelegateCtx = stripTransportSelectionRoutingContext(delegateCtx);
               const normalizedDelegateCtx = ensureDelegationContextMetadata(
-                attachDelegationRequestSnapshot(
-                  stripDelegationRequestSnapshot(routedDelegateCtx)
+                restoreDelegationRequestSnapshot(
+                  attachDelegationRequestSnapshot(routedDelegateCtx)
                 )
               );
               delete normalizedDelegateCtx.__isSubMeta;
@@ -14915,13 +15721,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,
@@ -15928,12 +16732,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_ENABLED4 = 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 = {
@@ -15950,6 +16800,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) => {
@@ -15983,6 +16841,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) => {
@@ -16303,16 +17258,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,
@@ -16403,7 +17362,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);
@@ -16631,6 +17590,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,
@@ -17707,7 +18672,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);
@@ -17775,7 +18740,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)) {
@@ -20065,10 +21030,23 @@ function resolveInquiryFailureError(inquiry, value, depth = 3, seen = /* @__PURE
   }
   return `Inquiry '${inquiry}' did not complete successfully`;
 }
+function normalizePositiveInteger2(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) {
@@ -20195,7 +21173,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;
     }
@@ -20203,7 +21189,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);
@@ -20211,32 +21198,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(
@@ -20244,7 +21252,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, {
@@ -20252,32 +21263,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
         );
       }
@@ -20290,9 +21317,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
@@ -20302,13 +21333,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
@@ -21563,10 +22599,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) => {
@@ -21579,10 +22633,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();
@@ -21637,7 +22714,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.
@@ -21898,11 +22979,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 = normalizePositiveInteger2(
+      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.
@@ -22320,6 +23474,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();
   }
 };
@@ -22333,9 +23492,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 = [];
@@ -22369,6 +23529,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) {