@cadenza.io/service 2.21.0 → 2.21.2

package/dist/browser/index.mjs

@@ -204,6 +204,16 @@ var DELEGATION_FAILURE_CONTEXT_KEYS = [
   "transportProtocols",
   "transportProtocol"
 ];
+var ACTOR_SESSION_STATE_REMOTE_ROUTINE = "Insert actor_session_state";
+var ACTOR_SESSION_SNAPSHOT_ROOT_KEYS = [
+  "__remoteRoutineName",
+  "__serviceName",
+  "__localTaskName",
+  "__localTaskVersion",
+  "__localServiceName",
+  "__timeout",
+  ...ROOT_METADATA_PASSTHROUGH_KEYS
+];
 function isPlainObject(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return false;
@@ -228,6 +238,9 @@ function cloneDelegationValue(value) {
   return value;
 }
 function buildDelegationRequestSnapshot(context) {
+  if (typeof context.__remoteRoutineName === "string" && context.__remoteRoutineName.trim() === ACTOR_SESSION_STATE_REMOTE_ROUTINE) {
+    return buildActorSessionDelegationSnapshot(context);
+  }
   const snapshot = {};
   for (const [key, value] of Object.entries(context)) {
     if (key === DELEGATION_REQUEST_SNAPSHOT_KEY || key === "task" || key === "routine") {
@@ -237,6 +250,21 @@ function buildDelegationRequestSnapshot(context) {
   }
   return snapshot;
 }
+function buildActorSessionDelegationSnapshot(context) {
+  const snapshot = {};
+  for (const key of ACTOR_SESSION_SNAPSHOT_ROOT_KEYS) {
+    if (context[key] !== void 0) {
+      snapshot[key] = cloneDelegationValue(context[key]);
+    }
+  }
+  if (context.data !== void 0) {
+    snapshot.data = cloneDelegationValue(context.data);
+  }
+  if (context.queryData !== void 0) {
+    snapshot.queryData = cloneDelegationValue(context.queryData);
+  }
+  return snapshot;
+}
 function hoistDelegationMetadataFields(input, metadataInput) {
   const context = input && typeof input === "object" ? { ...input } : {};
   const mutableContext = context;
@@ -345,6 +373,12 @@ function deputyTaskExecutor(context, emit2, inquire, _tools, progressCallback) {
       return;
     }
     const processId = uuid2();
+    const resolvedTimeoutMs = Math.max(
+      1e3,
+      Number(context.__timeout ?? task.timeout ?? 0) || 6e4
+    );
+    let settled = false;
+    let timeoutHandle = null;
     context.__metadata.__deputyExecId = processId;
     if ((process.env.CADENZA_INSTANCE_DEBUG === "1" || process.env.CADENZA_INSTANCE_DEBUG === "true") && context.__remoteRoutineName === "Insert service_instance") {
       console.log("[CADENZA_INSTANCE_DEBUG] deputy_delegation_requested", {
@@ -361,7 +395,37 @@ function deputyTaskExecutor(context, emit2, inquire, _tools, progressCallback) {
     emit2("meta.deputy.delegation_requested", {
       ...context
     });
-    CadenzaService.createEphemeralMetaTask(
+    let progressTask = null;
+    let resolveTask = null;
+    const cleanup = () => {
+      if (timeoutHandle) {
+        clearTimeout(timeoutHandle);
+        timeoutHandle = null;
+      }
+      if (progressTask && !progressTask.destroyed) {
+        progressTask.destroy();
+      }
+      if (resolveTask && !resolveTask.destroyed) {
+        resolveTask.destroy();
+      }
+    };
+    const settleSuccess = (value) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanup();
+      resolve(value);
+    };
+    const settleFailure = (error) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanup();
+      reject(error instanceof Error ? error : new Error(String(error)));
+    };
+    progressTask = CadenzaService.createEphemeralMetaTask(
       `On progress deputy ${task.remoteRoutineName}`,
       (ctx) => {
         if (typeof progressCallback === "function" && ctx.progress) {
@@ -380,7 +444,7 @@ function deputyTaskExecutor(context, emit2, inquire, _tools, progressCallback) {
       `meta.fetch.delegated:${processId}`,
       `meta.service_registry.load_balance_failed:${processId}`
     );
-    CadenzaService.createEphemeralMetaTask(
+    resolveTask = CadenzaService.createEphemeralMetaTask(
       `Resolve deputy ${task.remoteRoutineName}`,
       (responseCtx) => {
         const mergedResponseCtx = responseCtx && typeof responseCtx === "object" ? {
@@ -388,7 +452,7 @@ function deputyTaskExecutor(context, emit2, inquire, _tools, progressCallback) {
           ...responseCtx
         } : responseCtx;
         if (responseCtx?.errored) {
-          reject(new Error(responseCtx.__error));
+          settleFailure(new Error(responseCtx.__error));
         } else {
           if (SERVICE_REGISTRY_TRACE_SERVICE.length > 0 && CadenzaService.serviceRegistry.serviceName === SERVICE_REGISTRY_TRACE_SERVICE && context.__remoteRoutineName === "Insert service_instance") {
             console.log(
@@ -405,7 +469,7 @@ function deputyTaskExecutor(context, emit2, inquire, _tools, progressCallback) {
           if (mergedResponseCtx && typeof mergedResponseCtx === "object") {
             delete mergedResponseCtx.__isDeputy;
           }
-          resolve(mergedResponseCtx);
+          settleSuccess(mergedResponseCtx);
         }
       },
       `Ephemeral resolver for deputy process ${processId}`,
@@ -415,6 +479,14 @@ function deputyTaskExecutor(context, emit2, inquire, _tools, progressCallback) {
       `meta.fetch.delegated:${processId}`,
       `meta.service_registry.load_balance_failed:${processId}`
     );
+    timeoutHandle = setTimeout(() => {
+      settleFailure(
+        new Error(
+          `Deputy task '${task.name}' timed out waiting for remote resolution after ${resolvedTimeoutMs}ms.`
+        )
+      );
+    }, resolvedTimeoutMs);
+    timeoutHandle.unref?.();
   });
 }
 var DeputyTask = class extends Task {
@@ -560,6 +632,21 @@ var EXECUTION_OBSERVABILITY_INSERT_ROUTINES = /* @__PURE__ */ new Set([
   "Insert task_execution",
   "Insert inquiry"
 ]);
+var ROOT_DB_OPERATION_CONTEXT_KEYS = [
+  "data",
+  "batch",
+  "transaction",
+  "onConflict",
+  "filter",
+  "fields",
+  "joins",
+  "sort",
+  "limit",
+  "offset",
+  "queryMode",
+  "aggregates",
+  "groupBy"
+];
 var DatabaseTask = class extends DeputyTask {
   /**
    * Constructs an instance of the class with the provided parameters, defining
@@ -668,6 +755,27 @@ var DatabaseTask = class extends DeputyTask {
     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 shouldCompactAuthorityBootstrapContext = this.serviceName === "CadenzaDB" && (ctx.__authorityBootstrapChannel === true || metadata.__authorityBootstrapChannel === true || ctx.__metadata?.__authorityBootstrapChannel === true);
+    const rootDbOperationContext = shouldCompactAuthorityBootstrapContext ? {} : {
+      data: nextQueryData.data ?? ctx.data,
+      batch: nextQueryData.batch ?? ctx.batch,
+      transaction: nextQueryData.transaction ?? ctx.transaction,
+      onConflict: Object.prototype.hasOwnProperty.call(nextQueryData, "onConflict") ? nextQueryData.onConflict : void 0,
+      filter: nextQueryData.filter ?? ctx.filter,
+      fields: nextQueryData.fields ?? ctx.fields,
+      joins: nextQueryData.joins ?? ctx.joins,
+      sort: nextQueryData.sort ?? ctx.sort,
+      limit: nextQueryData.limit ?? ctx.limit,
+      offset: nextQueryData.offset ?? ctx.offset,
+      queryMode: nextQueryData.queryMode ?? ctx.queryMode,
+      aggregates: nextQueryData.aggregates ?? ctx.aggregates,
+      groupBy: nextQueryData.groupBy ?? ctx.groupBy
+    };
+    if (shouldCompactAuthorityBootstrapContext) {
+      for (const key of ROOT_DB_OPERATION_CONTEXT_KEYS) {
+        delete ctx[key];
+      }
+    }
     const deputyContext = attachDelegationRequestSnapshot(
       stripDelegationRequestSnapshot(
         hoistDelegationMetadataFields({
@@ -687,12 +795,7 @@ var DatabaseTask = class extends DeputyTask {
             __blockRemoteExecution: metadata.__blockRemoteExecution ?? ctx.__blockRemoteExecution ?? false,
             __deputyTaskName: this.name
           },
-          data: nextQueryData.data ?? ctx.data,
-          batch: nextQueryData.batch ?? ctx.batch,
-          transaction: nextQueryData.transaction ?? ctx.transaction,
-          onConflict: Object.prototype.hasOwnProperty.call(nextQueryData, "onConflict") ? nextQueryData.onConflict : void 0,
-          filter: nextQueryData.filter ?? ctx.filter,
-          fields: nextQueryData.fields ?? ctx.fields,
+          ...rootDbOperationContext,
           queryData: nextQueryData
         })
       )
@@ -1857,6 +1960,163 @@ function getAuthorityBootstrapInsertIntentSpecForTable(tableName) {
   return getAuthorityBootstrapIntentSpec(intentName);
 }
 
+// src/execution/ExecutionPersistenceCoordinator.ts
+var EXECUTION_PERSISTENCE_BUNDLE_SIGNAL = "global.meta.execution_persistence.bundle_requested";
+function readString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : null;
+}
+function readRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? { ...value } : null;
+}
+function normalizeRoutineExecutionTraceFields(data) {
+  if (!data) {
+    return null;
+  }
+  const normalizedData = { ...data };
+  const traceId = readString(
+    normalizedData.execution_trace_id ?? normalizedData.executionTraceId
+  );
+  const metaContext = readRecord(normalizedData.meta_context) ?? readRecord(normalizedData.metaContext);
+  const isMeta = normalizedData.is_meta === true || normalizedData.isMeta === true;
+  const serviceName = readString(
+    normalizedData.service_name ?? normalizedData.serviceName
+  );
+  const serviceInstanceId = readString(
+    normalizedData.service_instance_id ?? normalizedData.serviceInstanceId
+  );
+  if (traceId) {
+    normalizedData.execution_trace_id = traceId;
+  }
+  if (metaContext) {
+    normalizedData.meta_context = metaContext;
+  }
+  if (normalizedData.is_meta !== void 0 || normalizedData.isMeta !== void 0) {
+    normalizedData.is_meta = isMeta;
+  }
+  if (serviceName) {
+    normalizedData.service_name = serviceName;
+  }
+  if (serviceInstanceId) {
+    normalizedData.service_instance_id = serviceInstanceId;
+  } else if (normalizedData.serviceInstanceId === null || normalizedData.service_instance_id === null) {
+    normalizedData.service_instance_id = null;
+  }
+  delete normalizedData.executionTraceId;
+  delete normalizedData.traceId;
+  delete normalizedData.metaContext;
+  delete normalizedData.isMeta;
+  delete normalizedData.serviceName;
+  delete normalizedData.serviceInstanceId;
+  return normalizedData;
+}
+function stripExecutionTraceServiceInstanceFields(data) {
+  if (!data) {
+    return null;
+  }
+  const normalizedData = { ...data };
+  delete normalizedData.serviceInstanceId;
+  delete normalizedData.service_instance_id;
+  return normalizedData;
+}
+function normalizeEnsureData(entityType, data) {
+  switch (entityType) {
+    case "execution_trace":
+      return stripExecutionTraceServiceInstanceFields(data);
+    case "routine_execution":
+      return normalizeRoutineExecutionTraceFields(data);
+    default:
+      return data;
+  }
+}
+function buildExecutionPersistenceDependency(entityType, entityId) {
+  const normalizedEntityId = readString(entityId);
+  return normalizedEntityId ? `${entityType}:${normalizedEntityId}` : null;
+}
+function resolveEnsureEntityId(entityType, data) {
+  switch (entityType) {
+    default:
+      return readString(data.uuid);
+  }
+}
+function resolveUpdateEntityId(_entityType, data, filter) {
+  return readString(
+    filter.uuid ?? filter.taskExecutionId ?? filter.task_execution_id ?? data.uuid ?? data.taskExecutionId ?? data.task_execution_id
+  );
+}
+function dedupeDependencies(values) {
+  return Array.from(
+    new Set(values.filter((value) => typeof value === "string"))
+  );
+}
+function resolveTraceIdFromData(data) {
+  if (!data) {
+    return null;
+  }
+  return readString(
+    data.traceId ?? data.executionTraceId ?? data.execution_trace_id ?? data.metaContext?.__executionTraceId ?? data.metaContext?.__metadata?.__executionTraceId ?? data.meta_context?.__executionTraceId ?? data.meta_context?.__metadata?.__executionTraceId
+  );
+}
+function buildExecutionPersistenceEnsureEvent(entityType, data, deps = []) {
+  const normalizedData = normalizeEnsureData(entityType, readRecord(data));
+  if (!normalizedData) {
+    return null;
+  }
+  const entityId = resolveEnsureEntityId(entityType, normalizedData);
+  if (!entityId) {
+    return null;
+  }
+  return {
+    kind: "ensure",
+    entityType,
+    entityId,
+    data: normalizedData,
+    deps: dedupeDependencies(deps)
+  };
+}
+function buildExecutionPersistenceUpdateEvent(entityType, data, filter, deps = []) {
+  const normalizedData = readRecord(data);
+  const normalizedFilter = readRecord(filter);
+  if (!normalizedData || !normalizedFilter) {
+    return null;
+  }
+  const entityId = resolveUpdateEntityId(
+    entityType,
+    normalizedData,
+    normalizedFilter
+  );
+  if (!entityId) {
+    return null;
+  }
+  return {
+    kind: "update",
+    entityType,
+    entityId,
+    data: normalizedData,
+    filter: normalizedFilter,
+    deps: dedupeDependencies(deps)
+  };
+}
+function createExecutionPersistenceBundle(input) {
+  const ensures = (input.ensures ?? []).filter(
+    (event) => Boolean(event)
+  );
+  const updates = (input.updates ?? []).filter(
+    (event) => Boolean(event)
+  );
+  if (ensures.length === 0 && updates.length === 0) {
+    return null;
+  }
+  const traceId = readString(input.traceId) ?? ensures.map((event) => resolveTraceIdFromData(event.data)).find((value) => Boolean(value)) ?? updates.map((event) => resolveTraceIdFromData(event.data)).find((value) => Boolean(value));
+  if (!traceId) {
+    return null;
+  }
+  return {
+    traceId,
+    ensures,
+    updates
+  };
+}
+
 // src/utils/tools.ts
 function formatTimestamp(timestamp) {
   return new Date(timestamp).toISOString();
@@ -2087,12 +2347,24 @@ function listManifestGlobals() {
     (globalDefinition) => Boolean(globalDefinition && !globalDefinition.destroyed)
   );
 }
-function isRoutingCriticalMetaSignal(_signal) {
-  return false;
+function isRoutingCriticalMetaSignal(signal) {
+  return ROUTING_CRITICAL_META_SIGNALS.has(signal.name);
 }
-function isRoutingCriticalMetaIntent(_intent) {
-  return false;
+function isRoutingCriticalMetaIntent(intent) {
+  return ROUTING_CRITICAL_META_INTENTS.has(intent.name);
 }
+var ROUTING_CRITICAL_META_INTENTS = /* @__PURE__ */ new Set([
+  AUTHORITY_BOOTSTRAP_FULL_SYNC_INTENT,
+  AUTHORITY_SERVICE_INSTANCE_REGISTER_INTENT,
+  AUTHORITY_SERVICE_INSTANCE_TRANSPORT_REGISTER_INTENT,
+  AUTHORITY_SERVICE_MANIFEST_REPORT_INTENT,
+  AUTHORITY_RUNTIME_STATUS_REPORT_INTENT
+]);
+var ROUTING_CRITICAL_META_SIGNALS = /* @__PURE__ */ new Set([
+  AUTHORITY_SERVICE_MANIFEST_UPDATED_SIGNAL,
+  EXECUTION_PERSISTENCE_BUNDLE_SIGNAL,
+  ...AUTHORITY_BOOTSTRAP_SIGNAL_NAMES
+]);
 function buildServiceManifestSnapshot(params) {
   const {
     serviceName,
@@ -2502,87 +2774,9 @@ function buildServiceManifestSnapshot(params) {
       `${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) => [
+      [...routingTasks, ...businessTasks].map((task) => [
         buildTaskKey(task),
         task
       ])
@@ -2601,7 +2795,7 @@ function buildServiceManifestSnapshot(params) {
   );
   const cumulativeSignals = publicationLayer === "routing_capability" ? routingSignals : publicationLayer === "business_structural" ? Array.from(
     new Map(
-      [...routingSignals, ...businessSignals, ...businessLocalMetaSignals].map(
+      [...routingSignals, ...businessSignals].map(
         (signal) => [signal.name, signal]
       )
     ).values()
@@ -2615,7 +2809,7 @@ function buildServiceManifestSnapshot(params) {
   ).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(
+      [...routingIntents, ...businessIntents].map(
         (intent) => [intent.name, intent]
       )
     ).values()
@@ -2627,16 +2821,7 @@ function buildServiceManifestSnapshot(params) {
       ])
     ).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(
+  const cumulativeActors = publicationLayer === "routing_capability" ? [] : publicationLayer === "business_structural" ? businessActors : Array.from(
     new Map(
       [...businessActors, ...localMetaActors].map((actor) => [
         buildActorKey(actor),
@@ -2646,16 +2831,7 @@ function buildServiceManifestSnapshot(params) {
   ).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(
+  const cumulativeRoutines = publicationLayer === "routing_capability" ? [] : publicationLayer === "business_structural" ? businessRoutines : Array.from(
     new Map(
       [...businessRoutines, ...localMetaRoutines].map((routine) => [
         buildRoutineKey(routine),
@@ -2781,14 +2957,7 @@ function buildServiceManifestSnapshot(params) {
       )
     ).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(
+  const cumulativeActorTaskMaps = publicationLayer === "routing_capability" ? [] : publicationLayer === "business_structural" ? businessActorTaskMaps : 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}`,
@@ -2816,8 +2985,8 @@ function buildServiceManifestSnapshot(params) {
     helpers: cumulativeHelpers,
     globals: cumulativeGlobals,
     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],
+    signalToTaskMaps: publicationLayer === "routing_capability" ? publishedSignalTaskMaps : publicationLayer === "local_meta_structural" ? [...publishedSignalTaskMaps, ...localMetaSignalTaskMaps] : publishedSignalTaskMaps,
+    intentToTaskMaps: publicationLayer === "routing_capability" ? publishedIntentTaskMaps : publicationLayer === "local_meta_structural" ? [...publishedIntentTaskMaps, ...localMetaIntentTaskMaps] : publishedIntentTaskMaps,
     actorTaskMaps: cumulativeActorTaskMaps,
     taskToRoutineMaps: cumulativeTaskToRoutineMaps,
     taskToHelperMaps: cumulativeTaskToHelperMaps,
@@ -2981,6 +3150,13 @@ var META_SERVICE_INSTANCE_SHUTDOWN_TRANSPORT_DEACTIVATION_SIGNAL = "meta.service
 var META_AUTHORITY_BOOTSTRAP_HANDSHAKE_REQUESTED_SIGNAL = "meta.service_registry.authority_bootstrap_handshake_requested";
 var META_RUNTIME_STATUS_REST_REFRESH_TICK_SIGNAL = "meta.service_registry.runtime_status.rest_refresh_tick";
 var AUTHORITY_BOOTSTRAP_HANDSHAKE_TIMEOUT_MS = 5e3;
+var AUTHORITY_BOOTSTRAP_HANDSHAKE_RETRY_DELAYS_MS = [
+  1e3,
+  3e3,
+  7e3,
+  15e3
+];
+var AUTHORITY_BOOTSTRAP_ROUTINE_TIMEOUT_MS = 6e4;
 var EARLY_FULL_SYNC_DELAYS_MS = [
   100,
   1500,
@@ -2990,25 +3166,41 @@ var EARLY_FULL_SYNC_DELAYS_MS = [
   45e3,
   7e4
 ];
+var PENDING_ROUTE_SELECTION_RETRY_DELAYS_MS = [
+  50,
+  125,
+  250,
+  500
+];
 var MIN_BOOTSTRAP_FULL_SYNC_ATTEMPTS = 4;
-var INTERNAL_RUNTIME_STATUS_TASK_NAMES = /* @__PURE__ */ new Set([
-  "Track local routine start",
-  "Track local routine end",
-  "Start runtime status sharing intervals",
-  "Broadcast runtime status",
-  "Flush local runtime status to authority",
-  "Monitor dependee heartbeat freshness",
-  "Refresh REST dependee runtime status",
-  "Resolve runtime status fallback inquiry",
-  "Respond runtime status inquiry",
-  "Respond readiness inquiry",
-  "Collect distributed readiness",
-  "Get status"
-]);
 var SERVICE_REGISTRY_TRACE_SERVICE2 = (process.env.CADENZA_SERVICE_REGISTRY_TRACE_SERVICE ?? "").trim();
 function shouldTraceServiceRegistry(serviceName) {
   return SERVICE_REGISTRY_TRACE_SERVICE2.length > 0 && serviceName === SERVICE_REGISTRY_TRACE_SERVICE2;
 }
+function getFetchFailureText(ctx) {
+  return String(ctx?.__error ?? ctx?.error ?? ctx?.message ?? "").trim();
+}
+function isTerminalFetchTransportFailure(ctx) {
+  const errorText = getFetchFailureText(ctx);
+  if (!errorText) {
+    return false;
+  }
+  return errorText.includes("ENOTFOUND") || errorText.includes("ECONNREFUSED") || errorText.includes("EHOSTUNREACH");
+}
+function isRecoverableFetchTransportFailure(ctx, options = {}) {
+  const errorText = getFetchFailureText(ctx);
+  if (!errorText) {
+    return false;
+  }
+  return errorText.includes("AbortError") || errorText.includes("The operation was aborted") || errorText.includes("socket hang up") || errorText.includes("ECONNRESET") || errorText.includes("ETIMEDOUT") || options.includeConnectionRefused === true && errorText.includes("ECONNREFUSED");
+}
+function isHardFetchHandshakeFailure(ctx) {
+  const errorText = getFetchFailureText(ctx);
+  if (!errorText) {
+    return false;
+  }
+  return isTerminalFetchTransportFailure(ctx) || isRecoverableFetchTransportFailure(ctx);
+}
 function normalizeLeaseStatus(value) {
   const status = String(value ?? "").trim();
   if (status === "active" || status === "non_responsive" || status === "inactive" || status === "deleted") {
@@ -3154,18 +3346,28 @@ function compactAuthorityBootstrapRequestBody(ctx) {
   if (!isBootstrapDbOperationRoutineName(ctx.__remoteRoutineName)) {
     return ctx;
   }
-  const queryData = ctx.queryData && typeof ctx.queryData === "object" ? { ...ctx.queryData } : null;
-  if (!queryData) {
-    return ctx;
+  const existingQueryData = ctx.queryData && typeof ctx.queryData === "object" ? { ...ctx.queryData } : {};
+  const compactQueryData = {};
+  for (const key of BOOTSTRAP_DB_OPERATION_CONTEXT_KEYS) {
+    if (Object.prototype.hasOwnProperty.call(existingQueryData, key)) {
+      compactQueryData[key] = existingQueryData[key];
+      continue;
+    }
+    if (Object.prototype.hasOwnProperty.call(ctx, key)) {
+      compactQueryData[key] = ctx[key];
+    }
   }
   const compacted = {
-    ...ctx,
-    queryData
+    __remoteRoutineName: ctx.__remoteRoutineName,
+    __serviceName: ctx.__serviceName,
+    __localServiceName: ctx.__localServiceName,
+    __timeout: ctx.__timeout,
+    __syncing: true,
+    __authorityBootstrapChannel: true,
+    queryData: compactQueryData
   };
-  for (const key of BOOTSTRAP_DB_OPERATION_CONTEXT_KEYS) {
-    if (Object.prototype.hasOwnProperty.call(queryData, key)) {
-      delete compacted[key];
-    }
+  if (typeof ctx.__reason === "string" && ctx.__reason.trim().length > 0) {
+    compacted.__reason = ctx.__reason;
   }
   return compacted;
 }
@@ -3885,6 +4087,11 @@ var ServiceRegistry = class _ServiceRegistry {
       handshakeEstablished: false
     };
     this.authorityBootstrapHandshakeInFlight = false;
+    this.authorityBootstrapHandshakeRetryTimer = null;
+    this.authorityBootstrapHandshakeRetryIndex = 0;
+    this.authorityBootstrapHandshakeRetryGeneration = 0;
+    this.authorityBootstrapHandshakeRetryReason = null;
+    this.authorityBootstrapRecoveryActive = false;
     this.authorityFullSyncResponderTask = null;
     this.authorityServiceCommunicationPersistenceTask = null;
     this.localLifecycleFlushActor = CadenzaService.createActor(
@@ -4420,7 +4627,13 @@ var ServiceRegistry = class _ServiceRegistry {
           return false;
         }
         this.clearTransportReadyFromContext(ctx);
-        const { serviceName, serviceInstanceId, serviceTransportId } = ctx;
+        const serviceName = resolveServiceNameFromContext(ctx);
+        const serviceInstanceId = String(
+          ctx.serviceInstanceId ?? ctx.__instance ?? ctx.filter?.uuid ?? ""
+        ).trim();
+        const serviceTransportId = String(
+          ctx.serviceTransportId ?? ctx.__transportId ?? ""
+        ).trim();
         if (serviceName === "CadenzaDB" && this.hasAuthorityBootstrapHandshakeEstablished()) {
           const currentAuthorityInstanceId = String(
             this.authorityBootstrapRoute.serviceInstanceId ?? ""
@@ -4436,6 +4649,26 @@ var ServiceRegistry = class _ServiceRegistry {
             return true;
           }
         }
+        const signalName = String(
+          ctx.__signalName ?? ctx.__signalEmission?.fullSignalName ?? ""
+        ).trim();
+        const isFetchHandshakeFailure = signalName === "meta.fetch.handshake_failed" || signalName.startsWith("meta.fetch.handshake_failed:");
+        const hardFetchHandshakeFailure = isFetchHandshakeFailure && isHardFetchHandshakeFailure(ctx);
+        const recoverableFetchHandshakeFailure = isFetchHandshakeFailure && isRecoverableFetchTransportFailure(ctx, {
+          includeConnectionRefused: true
+        });
+        const isFetchDelegateFailure = signalName === "meta.fetch.delegate_failed" || signalName.startsWith("meta.fetch.delegate_failed:");
+        const hardFetchDelegateFailure = isFetchDelegateFailure && isHardFetchHandshakeFailure(ctx);
+        const recoverableFetchDelegateFailure = isFetchDelegateFailure && isRecoverableFetchTransportFailure(ctx);
+        if (isFetchDelegateFailure && !hardFetchDelegateFailure) {
+          return false;
+        }
+        if (serviceName === "CadenzaDB" && (isFetchHandshakeFailure && recoverableFetchHandshakeFailure || isFetchDelegateFailure && recoverableFetchDelegateFailure)) {
+          return false;
+        }
+        if (serviceName === "CadenzaDB" && this.authorityBootstrapRecoveryActive) {
+          return false;
+        }
         const serviceInstances = this.instances.get(serviceName);
         const instances = serviceInstances?.filter((instance) => {
           if (serviceInstanceId && instance.uuid === serviceInstanceId) {
@@ -4459,6 +4692,9 @@ var ServiceRegistry = class _ServiceRegistry {
           "warning",
           serviceName
         );
+        if (serviceName === "CadenzaDB") {
+          this.restartAuthorityBootstrapRecovery("cadenza_db_unreachable");
+        }
         for (const instance of instances ?? []) {
           if (instance.serviceName === this.serviceName && instance.uuid === this.serviceInstanceId) {
             continue;
@@ -4467,13 +4703,9 @@ var ServiceRegistry = class _ServiceRegistry {
           if (affectedTransport && this.hasAnyReadyClientProtocolForTransport(instance, affectedTransport)) {
             continue;
           }
-          const signalName = String(
-            ctx.__signalName ?? ctx.__signalEmission?.fullSignalName ?? ""
-          ).trim();
-          const isFetchHandshakeFailure = signalName === "meta.fetch.handshake_failed" || signalName.startsWith("meta.fetch.handshake_failed:");
-          if (isFetchHandshakeFailure && affectedTransport && this.isCurrentRouteContext(ctx) && this.scheduleDependeeClientRecovery(instance, affectedTransport, {
+          if ((isFetchHandshakeFailure && (!hardFetchHandshakeFailure || recoverableFetchHandshakeFailure) || isFetchDelegateFailure && (!hardFetchDelegateFailure || recoverableFetchDelegateFailure)) && affectedTransport && this.isCurrentRouteContext(ctx) && this.scheduleDependeeClientRecovery(instance, affectedTransport, {
             ...ctx,
-            __reason: "fetch_handshake_failed_retry"
+            __reason: isFetchDelegateFailure ? "fetch_delegate_failed_retry" : "fetch_handshake_failed_retry"
           })) {
             continue;
           }
@@ -4484,10 +4716,36 @@ var ServiceRegistry = class _ServiceRegistry {
             });
             continue;
           }
+          if (isFetchHandshakeFailure && recoverableFetchHandshakeFailure || isFetchDelegateFailure && recoverableFetchDelegateFailure) {
+            continue;
+          }
           this.applyInstanceLifecycleState(instance, {
             isActive: false,
             isNonResponsive: true
           });
+          const transportsToClear = affectedTransport ? [affectedTransport] : (instance.transports ?? []).filter((transport) => !transport.deleted);
+          for (const transport of transportsToClear) {
+            this.clearTransportFailureState(instance.uuid, transport.uuid);
+            this.clearTransportClientState(instance, transport);
+            this.clearRemoteRouteRecordIfCurrent(
+              instance.serviceName,
+              instance.uuid,
+              transport
+            );
+            this.emitTransportHandleShutdowns(
+              emit2,
+              this.buildTransportRouteKey(instance.serviceName, transport),
+              transport
+            );
+          }
+          emit2("meta.service_registry.service_not_responding", {
+            ...ctx,
+            serviceName: instance.serviceName,
+            serviceInstanceId: instance.uuid,
+            serviceTransportId: affectedTransport?.uuid ?? serviceTransportId ?? void 0,
+            routeKey: affectedTransport ? this.buildTransportRouteKey(instance.serviceName, affectedTransport) : ctx.routeKey ?? ctx.__routeKey,
+            __routeKey: affectedTransport ? this.buildTransportRouteKey(instance.serviceName, affectedTransport) : ctx.__routeKey ?? ctx.routeKey
+          });
           emit2("global.meta.service_registry.service_not_responding", {
             data: {
               isActive: false,
@@ -4516,6 +4774,8 @@ var ServiceRegistry = class _ServiceRegistry {
     ).doOn(
       "meta.fetch.handshake_failed",
       "meta.fetch.handshake_failed.*",
+      "meta.fetch.delegate_failed",
+      "meta.fetch.delegate_failed.*",
       "meta.socket_client.disconnected",
       "meta.socket_client.disconnected.*",
       "meta.service_registry.runtime_status_unreachable"
@@ -4701,12 +4961,10 @@ var ServiceRegistry = class _ServiceRegistry {
             return false;
           }
         }
-        this.invalidateAuthorityBootstrapHandshake();
-        this.invalidateBootstrapFullSyncRetryState("cadenza_db_unreachable");
-        CadenzaService.emit(META_AUTHORITY_BOOTSTRAP_HANDSHAKE_REQUESTED_SIGNAL, {
-          ...ctx,
-          __reason: "cadenza_db_unreachable"
-        });
+        if (this.authorityBootstrapRecoveryActive) {
+          return false;
+        }
+        this.restartAuthorityBootstrapRecovery("cadenza_db_unreachable");
         return true;
       },
       "Clears bootstrap full-sync retry satisfaction when the authority becomes unreachable."
@@ -4726,7 +4984,7 @@ var ServiceRegistry = class _ServiceRegistry {
           return false;
         }
         this.ensureBootstrapAuthorityControlPlane(ctx, emit2);
-        return this.restartBootstrapFullSyncRetryChain(
+        return this.scheduleNextBootstrapFullSyncRetry(
           "cadenza_db_fetch_handshake"
         );
       },
@@ -5093,12 +5351,24 @@ var ServiceRegistry = class _ServiceRegistry {
           preferredRole,
           preferredProtocol
         );
+        if (this.shouldDemandEstablishRemoteClients(context)) {
+          this.ensureDependeeClientsForService(__serviceName, emit2, context);
+        }
+        const hasPendingRouteableInstance = Boolean(__serviceName) && __serviceName !== "CadenzaDB" && this.hasPendingRouteableInstanceForSelection(
+          __serviceName,
+          context,
+          preferredRole,
+          targetServiceInstanceId
+        );
         const activeRoutingCooldown = __serviceName && !targetServiceInstanceId ? this.getActiveRoutingCooldown(
           __serviceName,
           preferredRole,
           preferredProtocol
         ) : null;
         if (activeRoutingCooldown) {
+          if (hasPendingRouteableInstance && this.maybeSchedulePendingRouteSelectionRetry(context, __serviceName)) {
+            return false;
+          }
           context.errored = true;
           context.__error = `No routeable ${preferredRole} transport available for ${__serviceName}. Waiting for authority route updates before retrying.`;
           emit2(
@@ -5140,9 +5410,6 @@ var ServiceRegistry = class _ServiceRegistry {
         }
         let retries = __retries ?? 0;
         let triedInstances = __triedInstances ?? [];
-        if (this.shouldDemandEstablishRemoteClients(context)) {
-          this.ensureDependeeClientsForService(__serviceName, emit2, context);
-        }
         const filteredInstances = this.instances.get(__serviceName)?.filter((instance) => {
           if (targetServiceInstanceId && instance.uuid !== targetServiceInstanceId) {
             return false;
@@ -5161,6 +5428,9 @@ var ServiceRegistry = class _ServiceRegistry {
             )
           );
         }) ?? [];
+        if (filteredInstances.length === 0 && __serviceName && hasPendingRouteableInstance && this.maybeSchedulePendingRouteSelectionRetry(context, __serviceName)) {
+          return false;
+        }
         const instances = this.collapseInstancesByRouteOrigin(
           filteredInstances,
           context,
@@ -5504,10 +5774,6 @@ var ServiceRegistry = class _ServiceRegistry {
     CadenzaService.createMetaTask(
       "Track local routine start",
       (ctx, emit2) => {
-        const sourceTaskName = String(ctx.__signalEmission?.taskName ?? "");
-        if (INTERNAL_RUNTIME_STATUS_TASK_NAMES.has(sourceTaskName)) {
-          return false;
-        }
         const routineId = String(
           ctx.filter?.uuid ?? ctx.__routineExecId ?? ""
         );
@@ -5538,10 +5804,6 @@ var ServiceRegistry = class _ServiceRegistry {
     CadenzaService.createMetaTask(
       "Track local routine end",
       (ctx, emit2) => {
-        const sourceTaskName = String(ctx.__signalEmission?.taskName ?? "");
-        if (INTERNAL_RUNTIME_STATUS_TASK_NAMES.has(sourceTaskName)) {
-          return false;
-        }
         const routineId = String(
           ctx.filter?.uuid ?? ctx.__routineExecId ?? ""
         );
@@ -6175,6 +6437,19 @@ var ServiceRegistry = class _ServiceRegistry {
           }
           return false;
         }
+        if (this.serviceName && normalizedLocalInstance.serviceName !== this.serviceName || this.serviceInstanceId && normalizedLocalInstance.uuid !== this.serviceInstanceId) {
+          if (shouldTraceServiceRegistry(
+            resolveServiceNameFromContext(ctx) || this.serviceName
+          )) {
+            console.log("[CADENZA_SERVICE_REGISTRY_TRACE] setup_service_ignored_non_local_instance", {
+              localServiceName: this.serviceName,
+              localServiceInstanceId: this.serviceInstanceId,
+              resolvedServiceName: normalizedLocalInstance.serviceName,
+              resolvedServiceInstanceId: normalizedLocalInstance.uuid
+            });
+          }
+          return false;
+        }
         if (shouldTraceServiceRegistry(normalizedLocalInstance.serviceName)) {
           console.log("[CADENZA_SERVICE_REGISTRY_TRACE] setup_service", {
             localServiceName: this.serviceName,
@@ -6390,7 +6665,8 @@ var ServiceRegistry = class _ServiceRegistry {
               security_profile: "excluded",
               auth_strategy: "excluded",
               deleted: "false"
-            }
+            },
+            where: "service_instance_transport.deleted IS DISTINCT FROM FALSE OR service_instance_transport.protocols IS DISTINCT FROM excluded.protocols OR service_instance_transport.security_profile IS DISTINCT FROM excluded.security_profile OR service_instance_transport.auth_strategy IS DISTINCT FROM excluded.auth_strategy"
           }
         }
       },
@@ -7322,6 +7598,7 @@ var ServiceRegistry = class _ServiceRegistry {
       serviceTransportId: String(ctx.serviceTransportId ?? "").trim() || null,
       handshakeEstablished: true
     };
+    this.markAuthorityBootstrapHandshakeSatisfied();
     return true;
   }
   getAuthorityBootstrapRestTarget() {
@@ -7350,6 +7627,92 @@ var ServiceRegistry = class _ServiceRegistry {
       handshakeEstablished: false
     };
   }
+  clearAuthorityBootstrapHandshakeRetryTimer() {
+    if (this.authorityBootstrapHandshakeRetryTimer) {
+      clearTimeout(this.authorityBootstrapHandshakeRetryTimer);
+      this.authorityBootstrapHandshakeRetryTimer = null;
+    }
+  }
+  invalidateAuthorityBootstrapHandshakeRetryState(reason) {
+    this.authorityBootstrapHandshakeRetryGeneration += 1;
+    this.clearAuthorityBootstrapHandshakeRetryTimer();
+    this.authorityBootstrapHandshakeRetryIndex = 0;
+    if (typeof reason === "string" && reason.trim()) {
+      this.authorityBootstrapHandshakeRetryReason = reason.trim();
+    }
+  }
+  markAuthorityBootstrapHandshakeSatisfied() {
+    this.clearAuthorityBootstrapHandshakeRetryTimer();
+    this.authorityBootstrapHandshakeRetryIndex = AUTHORITY_BOOTSTRAP_HANDSHAKE_RETRY_DELAYS_MS.length;
+    this.authorityBootstrapHandshakeRetryReason = null;
+    this.authorityBootstrapRecoveryActive = false;
+  }
+  buildJitteredAuthorityBootstrapHandshakeRetryDelayMs(baseDelayMs, attempt) {
+    return buildDeterministicJitteredDelayMs(
+      baseDelayMs,
+      this.bootstrapFullSyncRetryJitterRatio,
+      this.buildDeterministicInstanceJitterKey(
+        `authority-bootstrap-handshake-retry-${attempt}`
+      )
+    );
+  }
+  scheduleAuthorityBootstrapHandshakeRetry(reason) {
+    if (!this.connectsToCadenzaDB || !this.serviceName || this.serviceName === "CadenzaDB") {
+      return false;
+    }
+    if (this.hasAuthorityBootstrapHandshakeEstablished()) {
+      return false;
+    }
+    if (this.authorityBootstrapHandshakeInFlight) {
+      return false;
+    }
+    if (typeof reason === "string" && reason.trim()) {
+      this.authorityBootstrapHandshakeRetryReason = reason.trim();
+    }
+    if (this.authorityBootstrapHandshakeRetryTimer) {
+      return false;
+    }
+    const retryGeneration = this.authorityBootstrapHandshakeRetryGeneration;
+    const retryReason = this.authorityBootstrapHandshakeRetryReason ?? "authority_bootstrap_handshake_retry";
+    const attempt = this.authorityBootstrapHandshakeRetryIndex + 1;
+    const baseDelayMs = AUTHORITY_BOOTSTRAP_HANDSHAKE_RETRY_DELAYS_MS[Math.min(
+      this.authorityBootstrapHandshakeRetryIndex,
+      AUTHORITY_BOOTSTRAP_HANDSHAKE_RETRY_DELAYS_MS.length - 1
+    )] ?? AUTHORITY_BOOTSTRAP_HANDSHAKE_RETRY_DELAYS_MS.at(-1);
+    const delayMs = this.buildJitteredAuthorityBootstrapHandshakeRetryDelayMs(
+      baseDelayMs,
+      attempt
+    );
+    this.authorityBootstrapHandshakeRetryIndex += 1;
+    this.authorityBootstrapHandshakeRetryTimer = setTimeout(() => {
+      this.authorityBootstrapHandshakeRetryTimer = null;
+      if (this.hasAuthorityBootstrapHandshakeEstablished() || this.authorityBootstrapHandshakeInFlight || retryGeneration !== this.authorityBootstrapHandshakeRetryGeneration) {
+        return;
+      }
+      this.requestAuthorityBootstrapHandshake({
+        __reason: retryReason,
+        __authorityBootstrapRetry: true,
+        __authorityBootstrapRetryAttempt: attempt
+      });
+    }, delayMs);
+    return true;
+  }
+  restartAuthorityBootstrapHandshakeRetryChain(reason) {
+    this.invalidateAuthorityBootstrapHandshakeRetryState(reason);
+    return this.scheduleAuthorityBootstrapHandshakeRetry(reason);
+  }
+  restartAuthorityBootstrapRecovery(reason) {
+    if (this.authorityBootstrapRecoveryActive) {
+      if (typeof reason === "string" && reason.trim()) {
+        this.authorityBootstrapHandshakeRetryReason = reason.trim();
+      }
+      return false;
+    }
+    this.authorityBootstrapRecoveryActive = true;
+    this.invalidateAuthorityBootstrapHandshake();
+    this.invalidateBootstrapFullSyncRetryState(reason);
+    return this.restartAuthorityBootstrapHandshakeRetryChain(reason);
+  }
   requestAuthorityBootstrapHandshake(ctx) {
     if (!this.connectsToCadenzaDB || !this.serviceName || this.serviceName === "CadenzaDB") {
       return false;
@@ -7556,12 +7919,16 @@ var ServiceRegistry = class _ServiceRegistry {
       return;
     }
     const deputyTaskName = `Inquire ${map.intentName} via ${map.serviceName} (${map.taskName} v${map.taskVersion})`;
-    const deputyTask = map.serviceName === "CadenzaDB" && isAuthorityBootstrapIntent(map.intentName) ? CadenzaService.createMetaTask(
+    const shouldUseAuthorityBootstrapTimeout = map.serviceName === "CadenzaDB" && isMetaIntentName(map.intentName);
+    const effectiveTimeout = shouldUseAuthorityBootstrapTimeout ? Math.max(map.timeout ?? 0, AUTHORITY_BOOTSTRAP_ROUTINE_TIMEOUT_MS) : map.timeout;
+    const authorityBootstrapIntentSpec = map.serviceName === "CadenzaDB" ? getAuthorityBootstrapIntentSpec(map.intentName) : null;
+    const authorityBootstrapTaskName = authorityBootstrapIntentSpec?.authorityTaskName ?? map.taskName;
+    const deputyTask = authorityBootstrapIntentSpec ? CadenzaService.createMetaTask(
       deputyTaskName,
       async (ctx) => this.invokeAuthorityBootstrapRoutine(
-        map.taskName,
+        authorityBootstrapTaskName,
         ctx,
-        map.timeout ?? 15e3
+        effectiveTimeout ?? AUTHORITY_BOOTSTRAP_ROUTINE_TIMEOUT_MS
       ),
       "Routes reserved authority bootstrap inquiries directly through the post-handshake authority control-plane channel.",
       {
@@ -7571,14 +7938,14 @@ var ServiceRegistry = class _ServiceRegistry {
     ) : isMetaIntentName(map.intentName) ? CadenzaService.createMetaDeputyTask(map.taskName, map.serviceName, {
       register: false,
       isHidden: true,
-      timeout: map.timeout,
+      timeout: effectiveTimeout,
       retryCount: 1,
       retryDelay: 50,
       retryDelayFactor: 1.2
     }) : CadenzaService.createDeputyTask(map.taskName, map.serviceName, {
       register: false,
       isHidden: true,
-      timeout: map.timeout,
+      timeout: effectiveTimeout,
       retryCount: 1,
       retryDelay: 50,
       retryDelayFactor: 1.2
@@ -7592,7 +7959,7 @@ var ServiceRegistry = class _ServiceRegistry {
       key,
       intentName: map.intentName,
       serviceName: map.serviceName,
-      remoteTaskName: map.taskName,
+      remoteTaskName: authorityBootstrapTaskName,
       remoteTaskVersion: map.taskVersion,
       localTaskName: deputyTask.name || deputyTaskName,
       localTask: deputyTask
@@ -7604,7 +7971,7 @@ var ServiceRegistry = class _ServiceRegistry {
         localServiceName: this.serviceName,
         intentName: map.intentName,
         remoteServiceName: map.serviceName,
-        remoteTaskName: map.taskName,
+        remoteTaskName: authorityBootstrapTaskName,
         remoteTaskVersion: map.taskVersion
       });
     }
@@ -8304,6 +8671,50 @@ var ServiceRegistry = class _ServiceRegistry {
       );
     });
   }
+  hasPendingRouteableInstanceForSelection(serviceName, ctx, role, targetServiceInstanceId) {
+    return (this.instances.get(serviceName) ?? []).some((instance) => {
+      if (targetServiceInstanceId && instance.uuid !== targetServiceInstanceId) {
+        return false;
+      }
+      if (!instance.isActive || instance.isNonResponsive || instance.isBlocked) {
+        return false;
+      }
+      if (instance.isFrontend) {
+        return false;
+      }
+      const transport = this.selectTransportForInstance(instance, ctx, role);
+      if (!transport) {
+        return false;
+      }
+      return !this.hasTransportClientReady(instance, transport);
+    });
+  }
+  maybeSchedulePendingRouteSelectionRetry(ctx, serviceName) {
+    const signalName = String(
+      ctx.__signalName ?? ctx.__signalEmission?.fullSignalName ?? ""
+    ).trim();
+    if (!signalName) {
+      return false;
+    }
+    const attempt = Math.max(
+      0,
+      Number(ctx.__pendingRouteSelectionAttempt ?? 0) || 0
+    );
+    const delayMs = PENDING_ROUTE_SELECTION_RETRY_DELAYS_MS[attempt];
+    if (delayMs === void 0) {
+      return false;
+    }
+    CadenzaService.schedule(
+      signalName,
+      {
+        ...ctx,
+        __pendingRouteSelectionAttempt: attempt + 1,
+        __pendingRouteSelectionServiceName: serviceName
+      },
+      delayMs
+    );
+    return true;
+  }
   refreshRoutingCooldownsForService(serviceName) {
     if (!serviceName) {
       return;
@@ -9123,8 +9534,8 @@ var ServiceRegistry = class _ServiceRegistry {
     this.refreshRoutingCooldownsForService(serviceName);
   }
   clearTransportReadyFromContext(ctx) {
-    const serviceName = String(ctx.serviceName ?? "").trim();
-    const explicitRouteKey = String(ctx.routeKey ?? "").trim() || parseTransportHandleKey(ctx.fetchId ?? ctx.__fetchId)?.routeKey || "";
+    const serviceName = resolveServiceNameFromContext(ctx);
+    const explicitRouteKey = String(ctx.routeKey ?? ctx.__routeKey ?? "").trim() || parseTransportHandleKey(ctx.fetchId ?? ctx.__fetchId)?.routeKey || "";
     const serviceTransportId = String(
       ctx.serviceTransportId ?? ctx.__transportId ?? ""
     ).trim();
@@ -10719,6 +11130,10 @@ var ServiceRegistry = class _ServiceRegistry {
     this.bootstrapFullSyncRetryGeneration = 0;
     this.bootstrapFullSyncSatisfied = false;
     this.bootstrapFullSyncRetryReason = null;
+    this.clearAuthorityBootstrapHandshakeRetryTimer();
+    this.authorityBootstrapHandshakeRetryIndex = 0;
+    this.authorityBootstrapHandshakeRetryGeneration = 0;
+    this.authorityBootstrapHandshakeRetryReason = null;
     this.knownGlobalSignalMaps.clear();
     this.authorityBootstrapRoute = {
       origin: null,
@@ -13154,163 +13569,6 @@ var SocketController = class _SocketController {
   }
 };
 
-// src/execution/ExecutionPersistenceCoordinator.ts
-var EXECUTION_PERSISTENCE_BUNDLE_SIGNAL = "global.meta.execution_persistence.bundle_requested";
-function readString(value) {
-  return typeof value === "string" && value.trim().length > 0 ? value : null;
-}
-function readRecord(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? { ...value } : null;
-}
-function normalizeRoutineExecutionTraceFields(data) {
-  if (!data) {
-    return null;
-  }
-  const normalizedData = { ...data };
-  const traceId = readString(
-    normalizedData.execution_trace_id ?? normalizedData.executionTraceId
-  );
-  const metaContext = readRecord(normalizedData.meta_context) ?? readRecord(normalizedData.metaContext);
-  const isMeta = normalizedData.is_meta === true || normalizedData.isMeta === true;
-  const serviceName = readString(
-    normalizedData.service_name ?? normalizedData.serviceName
-  );
-  const serviceInstanceId = readString(
-    normalizedData.service_instance_id ?? normalizedData.serviceInstanceId
-  );
-  if (traceId) {
-    normalizedData.execution_trace_id = traceId;
-  }
-  if (metaContext) {
-    normalizedData.meta_context = metaContext;
-  }
-  if (normalizedData.is_meta !== void 0 || normalizedData.isMeta !== void 0) {
-    normalizedData.is_meta = isMeta;
-  }
-  if (serviceName) {
-    normalizedData.service_name = serviceName;
-  }
-  if (serviceInstanceId) {
-    normalizedData.service_instance_id = serviceInstanceId;
-  } else if (normalizedData.serviceInstanceId === null || normalizedData.service_instance_id === null) {
-    normalizedData.service_instance_id = null;
-  }
-  delete normalizedData.executionTraceId;
-  delete normalizedData.traceId;
-  delete normalizedData.metaContext;
-  delete normalizedData.isMeta;
-  delete normalizedData.serviceName;
-  delete normalizedData.serviceInstanceId;
-  return normalizedData;
-}
-function stripExecutionTraceServiceInstanceFields(data) {
-  if (!data) {
-    return null;
-  }
-  const normalizedData = { ...data };
-  delete normalizedData.serviceInstanceId;
-  delete normalizedData.service_instance_id;
-  return normalizedData;
-}
-function normalizeEnsureData(entityType, data) {
-  switch (entityType) {
-    case "execution_trace":
-      return stripExecutionTraceServiceInstanceFields(data);
-    case "routine_execution":
-      return normalizeRoutineExecutionTraceFields(data);
-    default:
-      return data;
-  }
-}
-function buildExecutionPersistenceDependency(entityType, entityId) {
-  const normalizedEntityId = readString(entityId);
-  return normalizedEntityId ? `${entityType}:${normalizedEntityId}` : null;
-}
-function resolveEnsureEntityId(entityType, data) {
-  switch (entityType) {
-    default:
-      return readString(data.uuid);
-  }
-}
-function resolveUpdateEntityId(_entityType, data, filter) {
-  return readString(
-    filter.uuid ?? filter.taskExecutionId ?? filter.task_execution_id ?? data.uuid ?? data.taskExecutionId ?? data.task_execution_id
-  );
-}
-function dedupeDependencies(values) {
-  return Array.from(
-    new Set(values.filter((value) => typeof value === "string"))
-  );
-}
-function resolveTraceIdFromData(data) {
-  if (!data) {
-    return null;
-  }
-  return readString(
-    data.traceId ?? data.executionTraceId ?? data.execution_trace_id ?? data.metaContext?.__executionTraceId ?? data.metaContext?.__metadata?.__executionTraceId ?? data.meta_context?.__executionTraceId ?? data.meta_context?.__metadata?.__executionTraceId
-  );
-}
-function buildExecutionPersistenceEnsureEvent(entityType, data, deps = []) {
-  const normalizedData = normalizeEnsureData(entityType, readRecord(data));
-  if (!normalizedData) {
-    return null;
-  }
-  const entityId = resolveEnsureEntityId(entityType, normalizedData);
-  if (!entityId) {
-    return null;
-  }
-  return {
-    kind: "ensure",
-    entityType,
-    entityId,
-    data: normalizedData,
-    deps: dedupeDependencies(deps)
-  };
-}
-function buildExecutionPersistenceUpdateEvent(entityType, data, filter, deps = []) {
-  const normalizedData = readRecord(data);
-  const normalizedFilter = readRecord(filter);
-  if (!normalizedData || !normalizedFilter) {
-    return null;
-  }
-  const entityId = resolveUpdateEntityId(
-    entityType,
-    normalizedData,
-    normalizedFilter
-  );
-  if (!entityId) {
-    return null;
-  }
-  return {
-    kind: "update",
-    entityType,
-    entityId,
-    data: normalizedData,
-    filter: normalizedFilter,
-    deps: dedupeDependencies(deps)
-  };
-}
-function createExecutionPersistenceBundle(input) {
-  const ensures = (input.ensures ?? []).filter(
-    (event) => Boolean(event)
-  );
-  const updates = (input.updates ?? []).filter(
-    (event) => Boolean(event)
-  );
-  if (ensures.length === 0 && updates.length === 0) {
-    return null;
-  }
-  const traceId = readString(input.traceId) ?? ensures.map((event) => resolveTraceIdFromData(event.data)).find((value) => Boolean(value)) ?? updates.map((event) => resolveTraceIdFromData(event.data)).find((value) => Boolean(value));
-  if (!traceId) {
-    return null;
-  }
-  return {
-    traceId,
-    ensures,
-    updates
-  };
-}
-
 // src/signals/SignalController.ts
 import { v4 as uuid5 } from "uuid";
 function resolveExecutionObservabilityServiceInstanceId() {
@@ -13463,7 +13721,7 @@ var SignalController = class _SignalController {
           intent: traceContext.__metadata?.__intent ?? traceContext.__intent ?? null,
           context: {
             id: uuid5(),
-            context: traceContext
+            context: sanitizedTraceContext
           },
           is_meta: signalEmission.isMeta,
           service_name: CadenzaService.serviceRegistry.serviceName,
@@ -14055,6 +14313,18 @@ import {
 } from "@cadenza.io/core";
 import { v4 as uuid6 } from "uuid";
 var ACTOR_TASK_METADATA2 = /* @__PURE__ */ Symbol.for("@cadenza.io/core/actor-task-meta");
+var ROUTING_CRITICAL_META_INTENTS2 = /* @__PURE__ */ new Set([
+  AUTHORITY_BOOTSTRAP_FULL_SYNC_INTENT,
+  AUTHORITY_SERVICE_INSTANCE_REGISTER_INTENT,
+  AUTHORITY_SERVICE_INSTANCE_TRANSPORT_REGISTER_INTENT,
+  AUTHORITY_SERVICE_MANIFEST_REPORT_INTENT,
+  AUTHORITY_RUNTIME_STATUS_REPORT_INTENT
+]);
+var ROUTING_CRITICAL_META_SIGNALS2 = /* @__PURE__ */ new Set([
+  AUTHORITY_SERVICE_MANIFEST_UPDATED_SIGNAL,
+  EXECUTION_PERSISTENCE_BUNDLE_SIGNAL,
+  ...AUTHORITY_BOOTSTRAP_SIGNAL_NAMES
+]);
 function getActorTaskRuntimeMetadata2(taskFunction) {
   if (typeof taskFunction !== "function") {
     return void 0;
@@ -14146,7 +14416,7 @@ function buildIntentRegistryData(intent) {
   };
 }
 function isLocalOnlySyncIntent(intentName) {
-  return intentName === META_ACTOR_SESSION_STATE_PERSIST_INTENT2;
+  return intentName === META_ACTOR_SESSION_STATE_PERSIST_INTENT2 || intentName.startsWith("meta-") || intentName.startsWith("global.meta-");
 }
 function getJoinedContextValue(ctx, key) {
   const joinedContexts = Array.isArray(ctx.joinedContexts) ? ctx.joinedContexts : [];
@@ -14186,6 +14456,32 @@ function buildMinimalSyncSignalContext(ctx, extra = {}) {
   }
   return nextContext;
 }
+function buildMinimalSyncShardContext(ctx, extra = {}) {
+  return {
+    ...buildMinimalSyncSignalContext(ctx, extra),
+    tasks: void 0,
+    signals: void 0,
+    intents: void 0,
+    actors: void 0,
+    routines: void 0,
+    serviceInstances: void 0,
+    service_instance_rows: void 0,
+    service_instance_transport_rows: void 0,
+    serviceManifests: void 0,
+    manifests: void 0,
+    signalToTaskMaps: void 0,
+    signal_to_task_maps: void 0,
+    intentToTaskMaps: void 0,
+    intent_to_task_maps: void 0,
+    actorTaskMaps: void 0,
+    actor_task_maps: void 0,
+    directionalTaskMaps: void 0,
+    directional_task_maps: void 0,
+    taskToRoutineMaps: void 0,
+    task_to_routine_maps: void 0,
+    task: void 0
+  };
+}
 function buildSyncInsertQueryData(ctx, queryData = {}) {
   const pickQueryData = (source, allowedKeys) => {
     const next = {};
@@ -14223,7 +14519,40 @@ var DEFAULT_SYNC_CYCLE_RUNTIME_STATE = {
   activeSyncCycleStartedAt: 0,
   phase: "idle"
 };
-var REMOTE_AUTHORITY_SYNC_INSERT_CONCURRENCY = 15;
+var REMOTE_AUTHORITY_SYNC_INSERT_CONCURRENCY = 2;
+function stripSyncResolverPayload(ctx) {
+  const nextContext = {
+    ...ctx
+  };
+  const bulkyStructuralKeys = [
+    "tasks",
+    "helpers",
+    "globals",
+    "signals",
+    "intents",
+    "actors",
+    "routines",
+    "serviceInstances",
+    "serviceInstanceTransports",
+    "serviceManifests",
+    "signalToTaskMaps",
+    "intentToTaskMaps",
+    "actorTaskMaps",
+    "directionalTaskMaps",
+    "taskToRoutineMaps",
+    "registeredGlobalSignals",
+    "registeredGlobalIntents",
+    "registeredActors",
+    "registeredRoutines"
+  ];
+  delete nextContext.__resolverOriginalContext;
+  delete nextContext.__resolverQueryData;
+  delete nextContext.joinedContexts;
+  for (const key of bulkyStructuralKeys) {
+    delete nextContext[key];
+  }
+  return nextContext;
+}
 function wireSyncTaskGraph(predecessorTask, graph, ...completionTasks) {
   if (!graph) {
     return void 0;
@@ -14235,28 +14564,14 @@ function wireSyncTaskGraph(predecessorTask, graph, ...completionTasks) {
   return graph.completionTask;
 }
 function buildSyncExecutionEnvelope(ctx, queryData) {
-  const originalContext = { ...ctx };
+  const originalContext = stripSyncResolverPayload(ctx);
   const syncSourceServiceName = typeof ctx.__syncSourceServiceName === "string" && ctx.__syncSourceServiceName.trim().length > 0 ? ctx.__syncSourceServiceName : typeof ctx.__serviceName === "string" && ctx.__serviceName.trim().length > 0 ? ctx.__serviceName : resolveSyncServiceName();
-  const rootDbOperationFields = {};
-  for (const key of [
-    "data",
-    "batch",
-    "transaction",
-    "onConflict",
-    "filter",
-    "fields"
-  ]) {
-    if (Object.prototype.hasOwnProperty.call(queryData, key)) {
-      rootDbOperationFields[key] = queryData[key];
-    }
-  }
   const nextContext = {
     __syncing: ctx.__syncing === true || ctx.__metadata?.__syncing === true || false,
     __syncSourceServiceName: syncSourceServiceName,
     __preferredTransportProtocol: "rest",
     __resolverOriginalContext: originalContext,
     __resolverQueryData: queryData,
-    ...rootDbOperationFields,
     queryData
   };
   if (typeof ctx.__reason === "string" && ctx.__reason.trim().length > 0) {
@@ -14275,6 +14590,7 @@ function resolveSyncInsertTask(isCadenzaDBReady, tableName, queryData = {}, opti
       Number(options.concurrency),
       REMOTE_AUTHORITY_SYNC_INSERT_CONCURRENCY
     ) : REMOTE_AUTHORITY_SYNC_INSERT_CONCURRENCY,
+    timeout: Number(options.timeout) > 0 ? Number(options.timeout) : 6e4,
     register: false,
     isHidden: true
   });
@@ -14314,13 +14630,15 @@ function resolveSyncInsertTask(isCadenzaDBReady, tableName, queryData = {}, opti
   const finalizeExecutionTask = CadenzaService.createMetaTask(
     `Finalize graph sync insert for ${tableName}`,
     (ctx) => {
-      const originalContext = ctx.__resolverOriginalContext && typeof ctx.__resolverOriginalContext === "object" ? ctx.__resolverOriginalContext : {};
+      const originalContext = ctx.__resolverOriginalContext && typeof ctx.__resolverOriginalContext === "object" ? stripSyncResolverPayload(
+        ctx.__resolverOriginalContext
+      ) : {};
       const originalQueryData = ctx.__resolverQueryData && typeof ctx.__resolverQueryData === "object" ? ctx.__resolverQueryData : void 0;
-      const normalizedContext = {
+      const normalizedContext = stripSyncResolverPayload({
         ...originalContext,
         ...ctx,
         queryData: ctx.queryData && typeof ctx.queryData === "object" ? ctx.queryData : originalQueryData
-      };
+      });
       if (originalContext.__syncing === true && !didSyncInsertSucceed(normalizedContext)) {
         CadenzaService.debounce("meta.sync_requested", {}, 1e3);
       }
@@ -14394,22 +14712,103 @@ function isBootstrapLocalOnlySignal(signalName) {
 function hasNonZeroPending(summary) {
   return Object.values(summary).some((value) => Number(value) > 0);
 }
+function shouldSkipIdleBootstrapSyncTrigger(input) {
+  if (input?.__forceSyncCycle === true) {
+    return false;
+  }
+  const triggerSignal = typeof input?.__signal === "string" ? input.__signal.trim() : "";
+  const reason = typeof input?.__reason === "string" ? input.__reason.trim() : "";
+  if (!triggerSignal) {
+    return input?.__bootstrapFullSync === true || reason.length > 0;
+  }
+  return triggerSignal === "meta.sync_controller.sync_tick" || triggerSignal === "meta.sync_requested";
+}
 function isRegistrableRoutine(routine) {
   return routine?.name !== "RestServer";
 }
 function scheduleSyncPassEvaluation(delayMs = SYNC_PASS_SETTLE_DELAY_MS) {
   CadenzaService.debounce(SYNC_PASS_EVALUATION_SIGNAL, {}, delayMs);
 }
+function isRoutingCriticalMetaSignalName(signalName) {
+  return ROUTING_CRITICAL_META_SIGNALS2.has(canonicalizeSignalName2(signalName));
+}
+function isRoutingCriticalMetaIntentName(intentName) {
+  return ROUTING_CRITICAL_META_INTENTS2.has(String(intentName ?? "").trim());
+}
+function isRoutingCapabilityBootstrapSignalName(signalName) {
+  const canonicalSignalName = canonicalizeSignalName2(signalName);
+  if (!canonicalSignalName) {
+    return false;
+  }
+  const signalParts = decomposeSignalName(canonicalSignalName);
+  if (!signalParts.isGlobal) {
+    return false;
+  }
+  if (signalParts.isMeta) {
+    return isRoutingCriticalMetaSignalName(canonicalSignalName);
+  }
+  return !isBootstrapLocalOnlySignal(canonicalSignalName);
+}
+function isRouteableBusinessBootstrapSignalName(signalName) {
+  const canonicalSignalName = canonicalizeSignalName2(signalName);
+  if (!canonicalSignalName) {
+    return false;
+  }
+  const signalParts = decomposeSignalName(canonicalSignalName);
+  if (!signalParts.isGlobal || signalParts.isMeta) {
+    return false;
+  }
+  return !isBootstrapLocalOnlySignal(canonicalSignalName);
+}
+function isRouteableBusinessBootstrapIntentName(intentName) {
+  const normalizedIntentName = String(intentName ?? "").trim();
+  return normalizedIntentName.length > 0 && !isLocalOnlySyncIntent(normalizedIntentName) && !isMetaIntentName(normalizedIntentName);
+}
+function isRoutingCapabilityBootstrapTask(task) {
+  if (!task || !task.register || task.isHidden || task.isDeputy) {
+    return false;
+  }
+  const isMetaTask = task.isMeta === true || task.isSubMeta === true;
+  for (const signalName of task.observedSignals) {
+    if (isMetaTask ? isRoutingCriticalMetaSignalName(signalName) : isRouteableBusinessBootstrapSignalName(signalName)) {
+      return true;
+    }
+  }
+  for (const intentName of task.handlesIntents) {
+    if (isMetaTask ? isRoutingCriticalMetaIntentName(intentName) : isRouteableBusinessBootstrapIntentName(intentName)) {
+      return true;
+    }
+  }
+  return false;
+}
+function shouldDirectSyncSignalTaskMapForBootstrap(task, signalName) {
+  const canonicalSignalName = canonicalizeSignalName2(signalName);
+  if (!task || !canonicalSignalName || task.isHidden || !task.register || !task.registered) {
+    return false;
+  }
+  if (!decomposeSignalName(canonicalSignalName).isGlobal) {
+    return false;
+  }
+  if (!isRegistrableBootstrapTask(task)) {
+    return false;
+  }
+  return isRoutingCapabilityBootstrapSignalName(canonicalSignalName);
+}
+function isRegistrableBootstrapTask(task) {
+  return isRoutingCapabilityBootstrapTask(task);
+}
 function getRegistrableTasks() {
   return Array.from(CadenzaService.registry.tasks.values()).filter(
-    (task) => task.register && !task.isHidden && !task.isDeputy
+    isRegistrableBootstrapTask
   );
 }
 function getBootstrapBlockingTasks() {
-  return getRegistrableTasks().filter((task) => task.isMeta !== true);
+  return getRegistrableTasks();
 }
 function getRegistrableRoutines() {
-  return Array.from(CadenzaService.registry.routines.values()).filter(isRegistrableRoutine);
+  return Array.from(CadenzaService.registry.routines.values()).filter(
+    isRegistrableRoutine
+  );
 }
 function getRegistrableSignalObservers() {
   const signalObservers = CadenzaService.signalBroker.signalObservers;
@@ -14419,19 +14818,23 @@ function getRegistrableSignalObservers() {
   const canonicalObservers = /* @__PURE__ */ new Map();
   for (const [rawSignalName, observer] of signalObservers.entries()) {
     const signalName = canonicalizeSignalName2(rawSignalName);
-    if (!signalName || isBootstrapLocalOnlySignal(signalName)) {
+    const isRoutingCriticalMetaSignal2 = signalName.length > 0 && isRoutingCriticalMetaSignalName(signalName);
+    if (!signalName || isBootstrapLocalOnlySignal(signalName) && !isRoutingCriticalMetaSignal2) {
+      continue;
+    }
+    if (!decomposeSignalName(signalName).isGlobal) {
       continue;
     }
     const observerTasks = Array.isArray(observer?.tasks) ? observer.tasks : observer?.tasks instanceof Set ? Array.from(observer.tasks) : [];
-    if (observerTasks.length > 0 && !observerTasks.some(
-      (task) => task?.register && !task.isHidden && !task.isDeputy
-    )) {
+    if (observerTasks.length > 0 && !observerTasks.some((task) => isRegistrableBootstrapTask(task))) {
       continue;
     }
+    const metadata = CadenzaService.signalBroker.getSignalMetadata(signalName) ?? null;
     const existing = canonicalObservers.get(signalName);
     canonicalObservers.set(signalName, {
       signalName,
-      registered: existing?.registered === true || observer?.registered === true
+      registered: existing?.registered === true || observer?.registered === true,
+      metadata: existing?.metadata ?? metadata
     });
   }
   return Array.from(canonicalObservers.values());
@@ -14442,7 +14845,10 @@ function isLocallyHandledIntentName(intentName) {
     return false;
   }
   for (const task of observer.tasks) {
-    if (task.register && !task.isHidden && !task.isDeputy) {
+    if (!task) {
+      continue;
+    }
+    if (isRegistrableBootstrapTask(task)) {
       return true;
     }
   }
@@ -14473,8 +14879,12 @@ function buildActorRegistrationKey(actor, serviceName) {
   return `${name}|${data.version}|${serviceName}`;
 }
 function isBootstrapRegistrableActor(actor) {
-  const actorName = String(buildActorRegistrationData(actor).name ?? "").trim();
-  return actorName.length > 0 && !isBootstrapLocalOnlyActorName(actorName);
+  const actorData = buildActorRegistrationData(actor);
+  const actorName = String(actorData.name ?? "").trim();
+  if (!actorName || isBootstrapLocalOnlyActorName(actorName)) {
+    return false;
+  }
+  return false;
 }
 function buildSignalTaskMapRegistrationKey(input) {
   return `${canonicalizeSignalName2(input.signalName)}|${input.serviceName}|${input.taskName}|${input.taskVersion ?? 1}`;
@@ -14641,6 +15051,7 @@ function resolveSignalNameFromSyncContext(ctx) {
 var GraphSyncController = class _GraphSyncController {
   constructor() {
     this.registeredActors = /* @__PURE__ */ new Set();
+    this.requestedActorRegistrations = /* @__PURE__ */ new Set();
     this.registeredActorTaskMaps = /* @__PURE__ */ new Set();
     this.registeredIntentDefinitions = /* @__PURE__ */ new Set();
     this.authoritativeSignalTaskMaps = /* @__PURE__ */ new Set();
@@ -14969,9 +15380,10 @@ var GraphSyncController = class _GraphSyncController {
         for (const routine of routines) {
           if (!isRegistrableRoutine(routine)) continue;
           if (routine.registered) continue;
+          if (routine.registrationRequested === true) continue;
+          routine.registrationRequested = true;
           this.routinesSynced = false;
-          yield {
-            __syncing: ctx.__syncing,
+          yield buildMinimalSyncShardContext(ctx, {
             data: {
               name: routine.name,
               version: routine.version,
@@ -14980,7 +15392,7 @@ var GraphSyncController = class _GraphSyncController {
               is_meta: routine.isMeta
             },
             __routineName: routine.name
-          };
+          });
         }
       }.bind(this)
     );
@@ -14998,15 +15410,19 @@ var GraphSyncController = class _GraphSyncController {
       { concurrency: 30 }
     );
     const registerRoutineTask = CadenzaService.createMetaTask("Register routine", (ctx) => {
+      const routine = resolveLocalRoutineFromSyncContext(ctx);
       if (!didSyncInsertSucceed(ctx)) {
+        if (routine) {
+          routine.registrationRequested = false;
+        }
         return;
       }
       scheduleSyncPassEvaluation();
-      const routine = resolveLocalRoutineFromSyncContext(ctx);
       if (!routine) {
         return true;
       }
       routine.registered = true;
+      routine.registrationRequested = false;
       return true;
     }).then(gatherRoutineRegistrationTask);
     wireSyncTaskGraph(this.splitRoutinesTask, routineRegistrationGraph, registerRoutineTask);
@@ -15033,8 +15449,7 @@ var GraphSyncController = class _GraphSyncController {
               if (!nextTask?.registered) {
                 continue;
               }
-              yield {
-                __syncing: ctx.__syncing,
+              yield buildMinimalSyncShardContext(ctx, {
                 data: {
                   task_name: nextTask.name,
                   task_version: nextTask.version,
@@ -15044,7 +15459,7 @@ var GraphSyncController = class _GraphSyncController {
                 },
                 __routineName: routine.name,
                 __taskName: nextTask.name
-              };
+              });
             }
           }
         }
@@ -15098,7 +15513,8 @@ var GraphSyncController = class _GraphSyncController {
           signalName: canonicalizeSignalName2(signal.signal),
           data: signal.data
         })).filter((signal) => {
-          if (!signal.signalName || signal.data?.registered || isBootstrapLocalOnlySignal(signal.signalName)) {
+          const isRoutingCriticalMetaSignal2 = isRoutingCriticalMetaSignalName(signal.signalName);
+          if (!signal.signalName || signal.data?.registered || isBootstrapLocalOnlySignal(signal.signalName) && !isRoutingCriticalMetaSignal2 || signal.data?.metadata?.is_meta === true && !isRoutingCriticalMetaSignal2) {
             return false;
           }
           if (seenSignals.has(signal.signalName)) {
@@ -15108,10 +15524,20 @@ var GraphSyncController = class _GraphSyncController {
           return true;
         }).map((signal) => signal.signalName);
         for (const signal of filteredSignals) {
+          const signalObservers = CadenzaService.signalBroker.signalObservers;
+          if (!signalObservers?.has(signal)) {
+            CadenzaService.signalBroker.addSignal(signal);
+          }
+          const observer = signalObservers?.get(signal);
+          if (observer?.registrationRequested === true) {
+            continue;
+          }
+          if (observer) {
+            observer.registrationRequested = true;
+          }
           const { isMeta, isGlobal, domain, action } = decomposeSignalName(signal);
           this.signalsSynced = false;
-          yield {
-            __syncing: ctx.__syncing,
+          yield buildMinimalSyncShardContext(ctx, {
             data: {
               name: signal,
               is_global: isGlobal,
@@ -15120,7 +15546,7 @@ var GraphSyncController = class _GraphSyncController {
               is_meta: isMeta
             },
             __signal: signal
-          };
+          });
         }
       }.bind(this)
     );
@@ -15142,21 +15568,25 @@ var GraphSyncController = class _GraphSyncController {
       (ctx, emit2) => {
         const insertSucceeded = didSyncInsertSucceed(ctx);
         const signalName = resolveSignalNameFromSyncContext(ctx);
+        const signalObservers = CadenzaService.signalBroker.signalObservers;
+        const observer = signalName ? signalObservers?.get(signalName) : void 0;
         if (!insertSucceeded) {
+          if (observer) {
+            observer.registrationRequested = false;
+          }
           return;
         }
         scheduleSyncPassEvaluation();
         if (!signalName) {
           return false;
         }
-        const signalObservers = CadenzaService.signalBroker.signalObservers;
         if (!signalObservers?.has(signalName)) {
           CadenzaService.signalBroker.addSignal(signalName);
         }
-        const observer = signalObservers?.get(signalName);
-        if (observer) {
-          observer.registered = true;
-          observer.registrationRequested = false;
+        const resolvedObserver = signalObservers?.get(signalName);
+        if (resolvedObserver) {
+          resolvedObserver.registered = true;
+          resolvedObserver.registrationRequested = false;
         }
         emit2(
           "meta.sync_controller.signal_registered",
@@ -15236,8 +15666,13 @@ var GraphSyncController = class _GraphSyncController {
           return;
         }
         for (const task of tasks) {
-          if (task.hidden || !task.register || task.isDeputy) continue;
+          if (!task) {
+            continue;
+          }
+          if (!isRegistrableBootstrapTask(task)) continue;
           if (task.registered) continue;
+          if (task.registrationRequested === true) continue;
+          task.registrationRequested = true;
           const { __functionString, __getTagCallback } = task.export();
           this.tasksSynced = false;
           const taskRegistrationData = sanitizePersistedTaskSourceFields(task, {
@@ -15272,11 +15707,10 @@ var GraphSyncController = class _GraphSyncController {
             },
             intents: Array.from(task.handlesIntents)
           });
-          yield {
-            __syncing: ctx.__syncing,
+          yield buildMinimalSyncShardContext(ctx, {
             data: taskRegistrationData,
             __taskName: task.name
-          };
+          });
         }
       }.bind(this)
     );
@@ -15297,9 +15731,11 @@ var GraphSyncController = class _GraphSyncController {
       "Record registration",
       (ctx, emit2) => {
         const task = resolveLocalTaskFromSyncContext(ctx);
-        const serviceName2 = resolveSyncServiceName(task);
         const insertSucceeded = didSyncInsertSucceed(ctx);
         if (!insertSucceeded) {
+          if (task) {
+            task.registrationRequested = false;
+          }
           return;
         }
         scheduleSyncPassEvaluation();
@@ -15341,11 +15777,15 @@ var GraphSyncController = class _GraphSyncController {
           if (this.registeredActors.has(registrationKey)) {
             continue;
           }
+          if (this.requestedActorRegistrations.has(registrationKey)) {
+            continue;
+          }
+          this.requestedActorRegistrations.add(registrationKey);
           this.actorsSynced = false;
-          yield {
+          yield buildMinimalSyncShardContext(ctx, {
             data,
             __actorRegistrationKey: registrationKey
-          };
+          });
         }
       }.bind(this)
     );
@@ -15365,11 +15805,18 @@ var GraphSyncController = class _GraphSyncController {
     const recordActorRegistrationTask = CadenzaService.createMetaTask(
       "Record actor registration",
       (ctx) => {
+        const registrationKey = typeof ctx.__actorRegistrationKey === "string" ? ctx.__actorRegistrationKey : "";
         if (!didSyncInsertSucceed(ctx)) {
+          if (registrationKey) {
+            this.requestedActorRegistrations.delete(registrationKey);
+          }
           return;
         }
         scheduleSyncPassEvaluation();
-        this.registeredActors.add(ctx.__actorRegistrationKey);
+        if (registrationKey) {
+          this.requestedActorRegistrations.delete(registrationKey);
+          this.registeredActors.add(registrationKey);
+        }
         return true;
       }
     ).then(gatherActorRegistrationTask);
@@ -15388,17 +15835,95 @@ var GraphSyncController = class _GraphSyncController {
       }
     );
     this.registerSignalToTaskMapTask = CadenzaService.createMetaTask(
-      "Defer signal task maps to manifest sync",
-      () => {
-        scheduleSyncPassEvaluation();
-        return false;
-      },
-      "Signal-task structural maps are derived from service manifests and authority full sync, not persisted incrementally on the hot registration path.",
+      "Register routing-critical signal task maps to DB",
+      function* (ctx) {
+        const task = ctx.task;
+        if (!task) {
+          return;
+        }
+        const serviceName2 = resolveSyncServiceName(task);
+        if (!serviceName2) {
+          return;
+        }
+        for (const signal of task.observedSignals) {
+          const signalName = canonicalizeSignalName2(signal);
+          if (!shouldDirectSyncSignalTaskMapForBootstrap(task, signalName)) {
+            continue;
+          }
+          if (task.registeredSignals.has(signalName)) {
+            continue;
+          }
+          const registrationKey = buildSignalTaskMapRegistrationKey({
+            signalName,
+            serviceName: serviceName2,
+            taskName: task.name,
+            taskVersion: task.version
+          });
+          if (this.authoritativeSignalTaskMaps.has(registrationKey)) {
+            continue;
+          }
+          if (!CadenzaService.signalBroker.signalObservers?.get(signalName)?.registered) {
+            continue;
+          }
+          yield buildMinimalSyncShardContext(ctx, {
+            data: {
+              signal_name: signalName,
+              is_global: true,
+              task_name: task.name,
+              task_version: task.version,
+              service_name: serviceName2
+            },
+            __taskName: task.name,
+            __signalName: signalName
+          });
+        }
+      }.bind(this),
+      "Routing-critical meta signal-task maps are persisted during bootstrap so authority can route required control-plane signals before deferred manifest replay completes.",
       {
         register: false,
         isHidden: true
       }
     );
+    const signalTaskMapRegistrationGraph = resolveSyncInsertTask(
+      this.isCadenzaDBReady,
+      "signal_to_task_map",
+      {
+        onConflict: {
+          target: [
+            "signal_name",
+            "is_global",
+            "task_name",
+            "task_version",
+            "service_name"
+          ],
+          action: {
+            do: "nothing"
+          }
+        }
+      },
+      { concurrency: 30 }
+    );
+    const recordSignalTaskMapRegistrationTask = CadenzaService.createMetaTask(
+      "Record signal task map registration",
+      (ctx) => {
+        if (!didSyncInsertSucceed(ctx)) {
+          return;
+        }
+        scheduleSyncPassEvaluation();
+        const task = CadenzaService.get(ctx.__taskName);
+        const signalName = typeof ctx.__signalName === "string" ? canonicalizeSignalName2(ctx.__signalName) : "";
+        if (!task || !signalName) {
+          return true;
+        }
+        task.registeredSignals.add(signalName);
+        return true;
+      }
+    );
+    wireSyncTaskGraph(
+      this.registerSignalToTaskMapTask,
+      signalTaskMapRegistrationGraph,
+      recordSignalTaskMapRegistrationTask
+    );
     this.splitIntentsTask = CadenzaService.createMetaTask(
       "Split intents for registration",
       function* (ctx) {
@@ -15414,25 +15939,31 @@ var GraphSyncController = class _GraphSyncController {
           if (this.registeredIntentDefinitions.has(intentData.name)) {
             continue;
           }
+          if (intent.registrationRequested === true) {
+            continue;
+          }
+          intent.registrationRequested = true;
           this.intentsSynced = false;
-          yield {
-            __syncing: ctx.__syncing,
+          yield buildMinimalSyncShardContext(ctx, {
             data: intentData,
             __intentName: intentData.name
-          };
+          });
         }
       }.bind(this)
     );
     const recordIntentDefinitionRegistrationTask = CadenzaService.createMetaTask(
       "Record intent definition registration",
       (ctx, emit2) => {
+        const intentName = typeof ctx.__intentName === "string" ? ctx.__intentName : "";
+        const intentDefinition = intentName ? CadenzaService.inquiryBroker.intents.get(intentName) ?? null : null;
         if (!didSyncInsertSucceed(ctx)) {
+          if (intentDefinition) {
+            intentDefinition.registrationRequested = false;
+          }
           return;
         }
         scheduleSyncPassEvaluation();
-        const intentName = typeof ctx.__intentName === "string" ? ctx.__intentName : "";
         this.registeredIntentDefinitions.add(intentName);
-        const intentDefinition = intentName ? CadenzaService.inquiryBroker.intents.get(intentName) ?? null : null;
         if (intentDefinition) {
           intentDefinition.registered = true;
           intentDefinition.registrationRequested = false;
@@ -15692,6 +16223,9 @@ var GraphSyncController = class _GraphSyncController {
       "Register task map to DB",
       function* (ctx) {
         const task = ctx.task;
+        if (!task) {
+          return;
+        }
         if (task.hidden || !task.register || task.isDeputy || !task.registered) {
           return;
         }
@@ -15700,6 +16234,9 @@ var GraphSyncController = class _GraphSyncController {
           return;
         }
         for (const t of task.nextTasks) {
+          if (!t) {
+            continue;
+          }
           if (task.taskMapRegistration.has(t.name) || t.hidden || !t.register || !t.registered || !shouldTrackDirectionalTaskMapForBootstrap(task, t)) {
             continue;
           }
@@ -15707,7 +16244,7 @@ var GraphSyncController = class _GraphSyncController {
           if (!serviceName2) {
             continue;
           }
-          yield {
+          yield buildMinimalSyncShardContext(ctx, {
             data: {
               task_name: t.name,
               task_version: t.version,
@@ -15718,7 +16255,7 @@ var GraphSyncController = class _GraphSyncController {
             },
             __taskName: task.name,
             __nextTaskName: t.name
-          };
+          });
         }
       }
     );
@@ -16306,19 +16843,6 @@ var GraphSyncController = class _GraphSyncController {
           if (!ServiceRegistry.instance.hasLocalInstanceRegistered()) {
             return false;
           }
-          if (ctx.__bootstrapFullSync === true) {
-            if (shouldTraceSyncPhase(serviceName2)) {
-              console.log(
-                "[CADENZA_SYNC_PHASE_TRACE] sync_cycle_ignored_bootstrap_full_sync",
-                {
-                  serviceName: serviceName2,
-                  reason: typeof ctx.__reason === "string" ? ctx.__reason : void 0,
-                  attempt: typeof ctx.__bootstrapFullSyncAttempt === "number" ? ctx.__bootstrapFullSyncAttempt : void 0
-                }
-              );
-            }
-            return false;
-          }
           if (state.activeSyncCycleId) {
             const activeCycleAgeMs = now - state.activeSyncCycleStartedAt;
             if (activeCycleAgeMs < BOOTSTRAP_SYNC_STALE_CYCLE_MS) {
@@ -16345,6 +16869,19 @@ var GraphSyncController = class _GraphSyncController {
               });
             }
           }
+          const primitivePendingSummary = buildPrimitivePendingSummary();
+          const mapPendingSummary = buildMapPendingSummary();
+          const hasPendingWork = hasNonZeroPending(primitivePendingSummary) || hasNonZeroPending(mapPendingSummary);
+          if (!hasPendingWork && shouldSkipIdleBootstrapSyncTrigger(ctx)) {
+            if (shouldTraceSyncPhase(serviceName2)) {
+              console.log("[CADENZA_SYNC_PHASE_TRACE] sync_cycle_skipped_idle", {
+                serviceName: serviceName2,
+                triggerSignal: typeof ctx.__signal === "string" ? ctx.__signal : void 0,
+                reason: typeof ctx.__reason === "string" ? ctx.__reason : void 0
+              });
+            }
+            return false;
+          }
           const syncCycleId = `${now}-${uuid6()}`;
           setRuntimeState({
             activeSyncCycleId: syncCycleId,
@@ -16453,22 +16990,43 @@ var GraphSyncController = class _GraphSyncController {
     const getSignalsForSyncTask = CadenzaService.createMetaTask(
       "Get signals for sync",
       (ctx) => {
-        const uniqueSignals = Array.from(
-          /* @__PURE__ */ new Set([
-            ...CadenzaService.signalBroker.signalObservers.keys(),
-            ...CadenzaService.signalBroker.emittedSignalsRegistry
-          ])
-        ).filter((signal) => !signal.includes(":"));
-        const processedSignals = uniqueSignals.map((signal) => ({
-          signal,
-          data: {
-            registered: CadenzaService.signalBroker.signalObservers.get(signal)?.registered ?? false,
-            metadata: CadenzaService.signalBroker.getSignalMetadata(signal) ?? null
+        const canonicalSignals = /* @__PURE__ */ new Map();
+        for (const observer of getRegistrableSignalObservers()) {
+          const signalName = canonicalizeSignalName2(observer.signalName);
+          if (!signalName || signalName.includes(":")) {
+            continue;
+          }
+          canonicalSignals.set(signalName, {
+            signal: signalName,
+            data: {
+              registered: observer.registered ?? false,
+              metadata: observer.metadata ?? null
+            }
+          });
+        }
+        for (const emittedSignal of CadenzaService.signalBroker.emittedSignalsRegistry) {
+          const signalName = canonicalizeSignalName2(emittedSignal);
+          if (!signalName || signalName.includes(":")) {
+            continue;
+          }
+          if (canonicalSignals.has(signalName)) {
+            continue;
           }
-        }));
+          const metadata = CadenzaService.signalBroker.getSignalMetadata(signalName) ?? null;
+          if (metadata?.is_meta === true || isBootstrapLocalOnlySignal(signalName)) {
+            continue;
+          }
+          canonicalSignals.set(signalName, {
+            signal: signalName,
+            data: {
+              registered: CadenzaService.signalBroker.signalObservers.get(signalName)?.registered ?? false,
+              metadata
+            }
+          });
+        }
         return {
           ...ctx,
-          signals: processedSignals
+          signals: Array.from(canonicalSignals.values())
         };
       },
       "Collects local signals for the primitive sync phase.",
@@ -16505,9 +17063,9 @@ var GraphSyncController = class _GraphSyncController {
       "Get all actors for sync",
       (ctx) => ({
         ...ctx,
-        actors: CadenzaService.getAllActors()
+        actors: []
       }),
-      "Collects local actors for the primitive sync phase.",
+      "Actor definitions are staged through service-manifest publication rather than the bootstrap primitive sync phase.",
       {
         register: false,
         isHidden: true
@@ -16539,7 +17097,7 @@ var GraphSyncController = class _GraphSyncController {
       "Iterate tasks for directional task map sync",
       function* (ctx) {
         for (const task of CadenzaService.registry.tasks.values()) {
-          yield { ...ctx, task };
+          yield buildMinimalSyncShardContext(ctx, { task });
         }
       },
       "Iterates local tasks for directional task-map sync.",
@@ -16558,7 +17116,7 @@ var GraphSyncController = class _GraphSyncController {
       "Iterate tasks for signal task map sync",
       function* (ctx) {
         for (const task of CadenzaService.registry.tasks.values()) {
-          yield { ...ctx, task };
+          yield buildMinimalSyncShardContext(ctx, { task });
         }
       },
       "Iterates local tasks for signal-to-task map sync.",
@@ -16572,12 +17130,12 @@ var GraphSyncController = class _GraphSyncController {
       gatherSignalTaskMapRegistrationTask
     );
     iterateTasksForSignalTaskMapSyncTask.then(this.registerSignalToTaskMapTask);
-    this.registerSignalToTaskMapTask.then(gatherSignalTaskMapRegistrationTask);
+    recordSignalTaskMapRegistrationTask.then(gatherSignalTaskMapRegistrationTask);
     const iterateTasksForIntentTaskMapSyncTask = CadenzaService.createMetaTask(
       "Iterate tasks for intent task map sync",
       function* (ctx) {
         for (const task of CadenzaService.registry.tasks.values()) {
-          yield { ...ctx, task };
+          yield buildMinimalSyncShardContext(ctx, { task });
         }
       },
       "Iterates local tasks for intent-to-task map sync.",
@@ -16596,7 +17154,7 @@ var GraphSyncController = class _GraphSyncController {
       "Iterate tasks for actor task map sync",
       function* (ctx) {
         for (const task of CadenzaService.registry.tasks.values()) {
-          yield { ...ctx, task };
+          yield buildMinimalSyncShardContext(ctx, { task });
         }
       },
       "Iterates local tasks for actor-to-task map sync.",
@@ -16729,7 +17287,7 @@ function sanitizePersistedTaskSourceFields2(task, data) {
   };
 }
 function shouldSkipDirectTaskMetadata(task) {
-  return !task || !task.register || task.isHidden || task.isDeputy;
+  return !task || !task.register || task.isHidden || task.isDeputy || task.isMeta || task.isSubMeta;
 }
 function isManagedRouteRecoveryTaskError(errorMessage) {
   if (typeof errorMessage !== "string") {
@@ -16743,7 +17301,10 @@ function isLocallyHandledIntentName2(intentName) {
     return false;
   }
   for (const task of observer.tasks) {
-    if (task.register && !task.isHidden && !task.isDeputy) {
+    if (!task) {
+      continue;
+    }
+    if (task.register && !task.isHidden && !task.isDeputy && !task.isMeta && !task.isSubMeta) {
       return true;
     }
   }
@@ -16982,7 +17543,7 @@ var GraphMetadataController = class _GraphMetadataController {
         return false;
       }
       const helper = resolveHelperFromMetadataContext(ctx);
-      if (!helper) {
+      if (!helper || helper.isMeta) {
         return false;
       }
       return buildDatabaseTriggerContext({
@@ -16997,7 +17558,7 @@ var GraphMetadataController = class _GraphMetadataController {
         return false;
       }
       const globalDefinition = resolveGlobalFromMetadataContext(ctx);
-      if (!globalDefinition) {
+      if (!globalDefinition || globalDefinition.isMeta) {
         return false;
       }
       return buildDatabaseTriggerContext({
@@ -17099,6 +17660,9 @@ var GraphMetadataController = class _GraphMetadataController {
       if (!shouldEmitDirectPrimitiveMetadata()) {
         return false;
       }
+      if (ctx.data?.isMeta === true) {
+        return false;
+      }
       return buildDatabaseTriggerContext({
         ...ctx.data,
         serviceName: CadenzaService.serviceRegistry.serviceName
@@ -17108,6 +17672,9 @@ var GraphMetadataController = class _GraphMetadataController {
       if (!shouldEmitDirectPrimitiveMetadata()) {
         return false;
       }
+      if (ctx.data?.isMeta === true) {
+        return false;
+      }
       return buildDatabaseTriggerContext(
         ctx.data ?? void 0,
         {
@@ -17776,6 +18343,9 @@ var GraphMetadataController = class _GraphMetadataController {
       if (!shouldEmitDirectPrimitiveMetadata()) {
         return false;
       }
+      if (ctx.data?.is_meta === true) {
+        return false;
+      }
       if (shouldSkipDirectActorMetadata(ctx?.data?.name)) {
         return false;
       }
@@ -17788,6 +18358,9 @@ var GraphMetadataController = class _GraphMetadataController {
       if (!shouldEmitDirectPrimitiveMetadata()) {
         return false;
       }
+      if (ctx.data?.is_meta === true) {
+        return false;
+      }
       if (shouldSkipDirectActorMetadata(ctx?.data?.actor_name)) {
         return false;
       }
@@ -18233,6 +18806,8 @@ function resetBrowserRuntimeActorHandles() {
 
 // src/Cadenza.ts
 var POSTGRES_SETUP_DEBUG_ENABLED = process.env.CADENZA_POSTGRES_SETUP_DEBUG === "1" || process.env.CADENZA_POSTGRES_SETUP_DEBUG === "true";
+var DEFAULT_SERVICE_MANIFEST_PUBLICATION_TIMEOUT_MS = 15e3;
+var LOCAL_AUTHORITY_SERVICE_MANIFEST_PUBLICATION_TIMEOUT_MS = 6e4;
 function resolveInquiryFailureError(inquiry, value, depth = 3, seen = /* @__PURE__ */ new Set()) {
   if (depth < 0 || value === null || value === void 0) {
     return `Inquiry '${inquiry}' did not complete successfully`;
@@ -18294,6 +18869,10 @@ var SERVICE_MANIFEST_PUBLICATION_ORDER = [
   "business_structural",
   "local_meta_structural"
 ];
+var ROUTING_CAPABILITY_PUBLICATION_RETRY_DELAY_MS = 250;
+var BUSINESS_STRUCTURAL_PUBLICATION_CALM_DELAY_MS = 1500;
+var LOCAL_META_STRUCTURAL_PUBLICATION_CALM_DELAY_MS = 15e3;
+var MANIFEST_PUBLICATION_PREREQUISITE_RETRY_DELAY_MS = 1e3;
 function getServiceManifestPublicationLayerRank(layer) {
   const index = SERVICE_MANIFEST_PUBLICATION_ORDER.indexOf(layer);
   return index >= 0 ? index : SERVICE_MANIFEST_PUBLICATION_ORDER.length - 1;
@@ -18427,43 +19006,250 @@ var CadenzaService = class {
   static normalizeServiceManifestPublicationLayer(value, fallback = "business_structural") {
     return value === "routing_capability" || value === "business_structural" || value === "local_meta_structural" ? value : fallback;
   }
+  static clampServiceManifestPublicationLayer(targetLayer) {
+    const maximumLayer = this.isLocalAuthorityService() ? "routing_capability" : "local_meta_structural";
+    return getServiceManifestPublicationLayerRank(targetLayer) > getServiceManifestPublicationLayerRank(maximumLayer) ? maximumLayer : targetLayer;
+  }
   static mergeServiceManifestPublicationRequest(reason, targetLayer) {
     this.serviceManifestPublicationPendingReason = reason;
+    const normalizedTargetLayer = this.clampServiceManifestPublicationLayer(targetLayer);
     const currentTargetLayer = this.serviceManifestPublicationPendingLayer ?? "routing_capability";
-    this.serviceManifestPublicationPendingLayer = getServiceManifestPublicationLayerRank(targetLayer) >= getServiceManifestPublicationLayerRank(currentTargetLayer) ? targetLayer : currentTargetLayer;
+    this.serviceManifestPublicationPendingLayer = getServiceManifestPublicationLayerRank(normalizedTargetLayer) >= getServiceManifestPublicationLayerRank(currentTargetLayer) ? normalizedTargetLayer : currentTargetLayer;
+  }
+  static getServiceManifestPublicationGate(publicationLayer) {
+    if (!this.localServiceManifestDefinitionInserted || !this.localServiceManifestInstanceInserted) {
+      return {
+        ready: false,
+        delayMs: ROUTING_CAPABILITY_PUBLICATION_RETRY_DELAY_MS
+      };
+    }
+    if (publicationLayer === "routing_capability") {
+      return {
+        ready: true,
+        delayMs: 0
+      };
+    }
+    if (!this.bootstrapSyncCompleted || this.bootstrapSyncCompletedAt <= 0) {
+      return {
+        ready: false,
+        delayMs: MANIFEST_PUBLICATION_PREREQUISITE_RETRY_DELAY_MS
+      };
+    }
+    const now = Date.now();
+    if (publicationLayer === "business_structural") {
+      const allowedAt2 = this.bootstrapSyncCompletedAt + BUSINESS_STRUCTURAL_PUBLICATION_CALM_DELAY_MS;
+      return {
+        ready: now >= allowedAt2,
+        delayMs: Math.max(1, allowedAt2 - now)
+      };
+    }
+    const businessPublishedAt = this.serviceManifestPublishedAt.business_structural ?? 0;
+    if (!this.lastPublishedServiceManifestHashes.business_structural || businessPublishedAt <= 0) {
+      return {
+        ready: false,
+        delayMs: MANIFEST_PUBLICATION_PREREQUISITE_RETRY_DELAY_MS
+      };
+    }
+    const allowedAt = businessPublishedAt + LOCAL_META_STRUCTURAL_PUBLICATION_CALM_DELAY_MS;
+    return {
+      ready: now >= allowedAt,
+      delayMs: Math.max(1, allowedAt - now)
+    };
   }
   static requestServiceManifestPublication(reason, immediate = false, targetLayer = "business_structural") {
     if (!this.serviceRegistry.serviceName || !this.serviceRegistry.serviceInstanceId) {
       return;
     }
+    const normalizedTargetLayer = this.clampServiceManifestPublicationLayer(targetLayer);
     const signalName = "meta.service_manifest.publish_requested";
     const payload = {
       __reason: reason,
       __serviceName: this.serviceRegistry.serviceName,
       __serviceInstanceId: this.serviceRegistry.serviceInstanceId,
-      __publicationLayer: targetLayer
+      __publicationLayer: normalizedTargetLayer
     };
     if (immediate) {
-      this.emit(signalName, payload);
+      if (this.serviceManifestPublicationRetryTimer) {
+        clearTimeout(this.serviceManifestPublicationRetryTimer);
+        this.serviceManifestPublicationRetryTimer = null;
+      }
+      void this.publishServiceManifestIfNeeded(reason, normalizedTargetLayer);
       return;
     }
     this.debounce(signalName, payload, 100);
   }
-  static scheduleServiceManifestPublicationRetry(reason, targetLayer = "business_structural") {
+  static scheduleServiceManifestPublicationRetry(reason, targetLayer = "business_structural", options) {
     if (!this.serviceRegistry.serviceName || !this.serviceRegistry.serviceInstanceId) {
       return;
     }
+    this.serviceManifestPublicationRetryReason = reason;
+    const normalizedTargetLayer = this.clampServiceManifestPublicationLayer(targetLayer);
+    const currentRetryLayer = this.serviceManifestPublicationRetryLayer ?? "routing_capability";
+    this.serviceManifestPublicationRetryLayer = getServiceManifestPublicationLayerRank(normalizedTargetLayer) >= getServiceManifestPublicationLayerRank(currentRetryLayer) ? normalizedTargetLayer : currentRetryLayer;
+    if (this.serviceManifestPublicationRetryTimer) {
+      return;
+    }
+    const retryReason = this.serviceManifestPublicationRetryReason ?? reason;
+    const retryTargetLayer = this.serviceManifestPublicationRetryLayer ?? targetLayer;
+    const shouldIncrementRetryCount = options?.incrementRetryCount !== false;
+    const delayMs = options?.delayMs ?? Math.min(
+      1e4,
+      1e3 * Math.max(1, 2 ** this.serviceManifestPublicationRetryCount)
+    );
+    if (shouldIncrementRetryCount) {
+      this.serviceManifestPublicationRetryCount += 1;
+    }
+    this.serviceManifestPublicationRetryTimer = setTimeout(() => {
+      this.serviceManifestPublicationRetryTimer = null;
+      const pendingReason = this.serviceManifestPublicationRetryReason ?? retryReason;
+      const pendingLayer = this.serviceManifestPublicationRetryLayer ?? retryTargetLayer;
+      this.serviceManifestPublicationRetryReason = null;
+      this.serviceManifestPublicationRetryLayer = null;
+      void this.publishServiceManifestIfNeeded(pendingReason, pendingLayer);
+    }, delayMs);
+  }
+  static shouldPublishBusinessManifestForTaskContext(ctx) {
+    const task = ctx?.taskInstance ?? (typeof ctx?.data?.name === "string" ? this.get(ctx.data.name) : void 0);
+    if (task) {
+      if (this.isRoutingCriticalManifestTask(task)) {
+        return true;
+      }
+      return task.register === true && task.isMeta !== true && task.isSubMeta !== true && task.isHidden !== true && task.isEphemeral !== true;
+    }
+    if (this.hasRoutingCriticalManifestBindingInContext(ctx)) {
+      return true;
+    }
+    return ctx?.data?.isMeta !== true && ctx?.data?.isSubMeta !== true && ctx?.data?.isHidden !== true && ctx?.data?.isEphemeral !== true && ctx?.__isSubMeta !== true;
+  }
+  static isRoutingCriticalManifestSignalName(signalName) {
+    const normalizedSignalName = String(signalName ?? "").trim();
+    if (!normalizedSignalName) {
+      return false;
+    }
+    return normalizedSignalName === EXECUTION_PERSISTENCE_BUNDLE_SIGNAL || isAuthorityBootstrapSignal(normalizedSignalName);
+  }
+  static isRoutingCriticalManifestIntentName(intentName) {
+    return isAuthorityBootstrapIntent(intentName);
+  }
+  static isRoutingCriticalManifestTask(task) {
+    for (const signalName of task.observedSignals ?? []) {
+      if (this.isRoutingCriticalManifestSignalName(signalName)) {
+        return true;
+      }
+    }
+    for (const intentName of task.handlesIntents ?? []) {
+      if (this.isRoutingCriticalManifestIntentName(intentName)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  static hasRoutingCriticalManifestBindingInContext(ctx) {
+    const signalCandidates = [
+      ctx?.signalName,
+      ctx?.data?.signalName,
+      ctx?.data?.signal_name
+    ];
+    for (const signalName of signalCandidates) {
+      if (this.isRoutingCriticalManifestSignalName(signalName)) {
+        return true;
+      }
+    }
+    const intentCandidates = [
+      ctx?.intentName,
+      ctx?.data?.intentName,
+      ctx?.data?.intent_name
+    ];
+    for (const intentName of intentCandidates) {
+      if (this.isRoutingCriticalManifestIntentName(intentName)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  static shouldPublishBusinessManifestForHelperContext(ctx) {
+    const helperName = typeof ctx?.data?.name === "string" ? ctx.data.name : typeof ctx?.data?.helperName === "string" ? ctx.data.helperName : typeof ctx?.data?.dependencyHelperName === "string" ? ctx.data.dependencyHelperName : "";
+    const helper = helperName ? Cadenza.getHelper(helperName) : void 0;
+    if (helper) {
+      return helper.isMeta !== true;
+    }
+    return ctx?.data?.isMeta !== true;
+  }
+  static shouldPublishBusinessManifestForGlobalContext(ctx) {
+    const globalName = typeof ctx?.data?.name === "string" ? ctx.data.name : typeof ctx?.data?.globalName === "string" ? ctx.data.globalName : "";
+    const globalDefinition = globalName ? Cadenza.getGlobal(globalName) : void 0;
+    if (globalDefinition) {
+      return globalDefinition.isMeta !== true;
+    }
+    return ctx?.data?.isMeta !== true;
+  }
+  static shouldPublishBusinessManifestForRoutineContext(ctx) {
+    const routineName = typeof ctx?.data?.name === "string" ? ctx.data.name : "";
+    const routine = routineName ? this.getRoutine(routineName) : void 0;
+    if (routine) {
+      return routine.isMeta !== true;
+    }
+    return ctx?.data?.isMeta !== true;
+  }
+  static shouldRequestServiceManifestPublicationForSignal(ctx) {
+    const signalName = typeof ctx?.signal === "string" && ctx.signal.trim().length > 0 ? ctx.signal.trim() : "";
+    switch (signalName) {
+      case "meta.task.created":
+      case "meta.task.destroyed":
+      case "meta.task.relationship_added":
+      case "meta.task.relationship_removed":
+      case "meta.task.intent_associated":
+      case "meta.task.helper_associated":
+      case "meta.task.global_associated":
+      case "meta.task.observed_signal":
+      case "meta.task.attached_signal":
+      case "meta.task.detached_signal":
+        return this.shouldPublishBusinessManifestForTaskContext(ctx);
+      case "meta.helper.created":
+      case "meta.helper.updated":
+      case "meta.helper.helper_associated":
+      case "meta.helper.global_associated":
+        return this.shouldPublishBusinessManifestForHelperContext(ctx);
+      case "meta.global.created":
+      case "meta.global.updated":
+        return this.shouldPublishBusinessManifestForGlobalContext(ctx);
+      case "meta.actor.created":
+      case "meta.actor.task_associated":
+        return ctx?.data?.is_meta !== true && ctx?.__isSubMeta !== true;
+      case "global.meta.graph_metadata.routine_created":
+      case "global.meta.graph_metadata.routine_updated":
+        return this.shouldPublishBusinessManifestForRoutineContext(ctx);
+      default:
+        return false;
+    }
+  }
+  static maybeRequestInitialServiceManifestPublication(reason, targetLayer = "business_structural") {
+    if (this.initialServiceManifestPublicationRequested || !this.canPublishServiceManifestToAuthority() || !this.serviceRegistry.serviceName || !this.serviceRegistry.serviceInstanceId || !this.localServiceManifestDefinitionInserted || !this.localServiceManifestInstanceInserted) {
+      return false;
+    }
+    this.initialServiceManifestPublicationRequested = true;
+    this.requestServiceManifestPublication(reason, true, targetLayer);
+    return true;
+  }
+  static scheduleInitialServiceManifestPublicationFallback(reason, targetLayer = "business_structural") {
+    if (!this.canPublishServiceManifestToAuthority() || !this.serviceRegistry.serviceName || !this.serviceRegistry.serviceInstanceId) {
+      return;
+    }
     setTimeout(() => {
-      this.requestServiceManifestPublication(reason, false, targetLayer);
+      if (this.initialServiceManifestPublicationRequested || !this.canPublishServiceManifestToAuthority() || !this.serviceRegistry.serviceName || !this.serviceRegistry.serviceInstanceId) {
+        return;
+      }
+      this.requestServiceManifestPublication(reason, true, targetLayer);
     }, 1e3);
   }
   static async publishServiceManifestIfNeeded(reason, targetLayer = "business_structural") {
-    if (!this.serviceRegistry.connectsToCadenzaDB || !this.serviceRegistry.serviceName || !this.serviceRegistry.serviceInstanceId) {
+    if (!this.canPublishServiceManifestToAuthority() || !this.serviceRegistry.serviceName || !this.serviceRegistry.serviceInstanceId) {
       return false;
     }
     const publishReason = typeof reason === "string" && reason.trim().length > 0 ? reason.trim() : "service_manifest_publish";
+    const normalizedTargetLayer = this.clampServiceManifestPublicationLayer(targetLayer);
     const publishTargetLayer = this.normalizeServiceManifestPublicationLayer(
-      targetLayer
+      normalizedTargetLayer
     );
     if (this.serviceManifestPublicationInFlight) {
       this.mergeServiceManifestPublicationRequest(
@@ -18496,13 +19282,23 @@ var CadenzaService = class {
     const hasPendingFollowupLayer = publicationPlan.some(
       (entry) => entry.changed && getServiceManifestPublicationLayerRank(entry.layer) > getServiceManifestPublicationLayerRank(publicationLayer)
     );
+    const publicationGate = this.getServiceManifestPublicationGate(publicationLayer);
+    if (!publicationGate.ready) {
+      this.scheduleServiceManifestPublicationRetry(publishReason, publishTargetLayer, {
+        delayMs: publicationGate.delayMs,
+        incrementRetryCount: false
+      });
+      return false;
+    }
     this.serviceManifestPublicationInFlight = true;
     try {
-      this.serviceRegistry.ensureBootstrapAuthorityControlPlaneForInquiry(
-        AUTHORITY_SERVICE_MANIFEST_REPORT_INTENT,
-        snapshot
-      );
-      if (!this.serviceRegistry.hasAuthorityBootstrapHandshakeEstablished()) {
+      if (!this.isLocalAuthorityService()) {
+        this.serviceRegistry.ensureBootstrapAuthorityControlPlaneForInquiry(
+          AUTHORITY_SERVICE_MANIFEST_REPORT_INTENT,
+          snapshot
+        );
+      }
+      if (this.shouldRequireAuthorityBootstrapHandshakeForManifestPublication() && !this.serviceRegistry.hasAuthorityBootstrapHandshakeEstablished()) {
         this.scheduleServiceManifestPublicationRetry(
           publishReason,
           publishTargetLayer
@@ -18510,11 +19306,13 @@ var CadenzaService = class {
         return false;
       }
       await this.inquire(AUTHORITY_SERVICE_MANIFEST_REPORT_INTENT, snapshot, {
-        timeout: 15e3,
+        timeout: this.isLocalAuthorityService() ? LOCAL_AUTHORITY_SERVICE_MANIFEST_PUBLICATION_TIMEOUT_MS : DEFAULT_SERVICE_MANIFEST_PUBLICATION_TIMEOUT_MS,
         requireComplete: true
       });
       this.serviceManifestRevision = snapshot.revision;
       this.lastPublishedServiceManifestHashes[publicationLayer] = snapshot.manifestHash;
+      this.serviceManifestPublishedAt[publicationLayer] = Date.now();
+      this.serviceManifestPublicationRetryCount = 0;
       if (hasPendingFollowupLayer) {
         this.mergeServiceManifestPublicationRequest(
           publishReason,
@@ -18550,14 +19348,7 @@ var CadenzaService = class {
         const pendingLayer = this.serviceManifestPublicationPendingLayer;
         this.serviceManifestPublicationPendingReason = null;
         this.serviceManifestPublicationPendingLayer = null;
-        this.debounce(
-          "meta.service_manifest.publish_requested",
-          {
-            __reason: pendingReason,
-            __publicationLayer: pendingLayer
-          },
-          100
-        );
+        void this.publishServiceManifestIfNeeded(pendingReason, pendingLayer);
       }
     }
   }
@@ -18571,7 +19362,7 @@ var CadenzaService = class {
         typeof ctx.__reason === "string" && ctx.__reason.trim().length > 0 ? ctx.__reason.trim() : "service_manifest_publish",
         this.normalizeServiceManifestPublicationLayer(
           ctx.__publicationLayer,
-          "business_structural"
+          "local_meta_structural"
         )
       ),
       "Publishes staged static manifest snapshots to authority when the manifest hash changes.",
@@ -18583,14 +19374,17 @@ var CadenzaService = class {
     this.createMetaTask(
       "Request manifest publication after structural change",
       (ctx) => {
+        if (!this.shouldRequestServiceManifestPublicationForSignal(ctx)) {
+          return false;
+        }
         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(
+        const targetLayer = this.normalizeServiceManifestPublicationLayer(
           ctx.__publicationLayer,
-          "business_structural"
+          "local_meta_structural"
         );
         this.requestServiceManifestPublication(
           reason,
-          reason === "meta.service_registry.instance_inserted",
+          false,
           targetLayer
         );
         return true;
@@ -18601,7 +19395,6 @@ var CadenzaService = class {
         isHidden: true
       }
     ).doOn(
-      "meta.service_registry.instance_inserted",
       "meta.task.created",
       "meta.task.destroyed",
       "meta.task.relationship_added",
@@ -18620,14 +19413,21 @@ var CadenzaService = class {
       "meta.helper.global_associated",
       "meta.actor.created",
       "meta.actor.task_associated",
-      "meta.fetch.handshake_complete",
       "meta.service_registry.registered_global_signals",
       "meta.service_registry.registered_global_intents",
-      "meta.service_registry.initial_sync_complete",
       "global.meta.graph_metadata.routine_created",
       "global.meta.graph_metadata.routine_updated"
     );
   }
+  static isLocalAuthorityService() {
+    return this.serviceRegistry.serviceName === "CadenzaDB";
+  }
+  static canPublishServiceManifestToAuthority() {
+    return this.serviceRegistry.connectsToCadenzaDB || this.isLocalAuthorityService();
+  }
+  static shouldRequireAuthorityBootstrapHandshakeForManifestPublication() {
+    return !this.isLocalAuthorityService();
+  }
   static buildLegacyLocalCadenzaDBTaskName(tableName, operation) {
     const operationPrefix = operation.charAt(0).toUpperCase() + operation.slice(1);
     const helperSuffix = camelCase(String(tableName ?? "").trim());
@@ -18794,6 +19594,7 @@ var CadenzaService = class {
   }
   static markBootstrapSyncCompleted() {
     this.bootstrapSyncCompleted = true;
+    this.bootstrapSyncCompletedAt = Date.now();
   }
   /**
    * Emits a signal with the specified data using the associated broker.
@@ -19624,6 +20425,7 @@ var CadenzaService = class {
     this.validateServiceName(serviceName);
     const serviceId = options.customServiceId ?? uuid7();
     this.bootstrapSyncCompleted = false;
+    this.bootstrapSyncCompletedAt = 0;
     this.bootstrapSignalRegistrationsCompleted = false;
     this.bootstrapIntentRegistrationsCompleted = false;
     this.serviceRegistry.serviceName = serviceName;
@@ -19859,6 +20661,7 @@ var CadenzaService = class {
       __declaredTransports: declaredTransports
     };
     let bootstrapServiceCreationRequested = false;
+    const emitLocalServiceCreationImmediately = !options.cadenzaDB?.connect;
     if (options.cadenzaDB?.connect) {
       this.createMetaTask(
         "Create service",
@@ -19881,7 +20684,6 @@ var CadenzaService = class {
         }
       ).doOn("meta.fetch.handshake_complete");
     } else {
-      this.emit("meta.create_service_requested", initContext);
       this.createMetaTask("Create signal transmission for sync", (ctx, emit2) => {
         emit2(
           "meta.service_registry.gathered_sync_transmission_reconcile_requested",
@@ -19893,6 +20695,20 @@ var CadenzaService = class {
       }).doOn("meta.rest.handshake", "meta.socket.handshake");
     }
     let serviceSetupCompletedHandled = false;
+    this.createMetaTask("Handle local service definition insertion", (ctx) => {
+      const insertedServiceName = String(
+        ctx?.__serviceName ?? ctx?.serviceName ?? ctx?.service_name ?? ctx?.data?.name ?? ""
+      ).trim();
+      if (!insertedServiceName || insertedServiceName !== serviceName) {
+        return false;
+      }
+      this.localServiceManifestDefinitionInserted = true;
+      this.maybeRequestInitialServiceManifestPublication(
+        "service_setup_completed",
+        "local_meta_structural"
+      );
+      return true;
+    }).doOn("meta.service_registry.service_inserted");
     this.createMetaTask("Handle service setup completion", (ctx, emit2) => {
       if (serviceSetupCompletedHandled) {
         return false;
@@ -19913,13 +20729,18 @@ var CadenzaService = class {
         return false;
       }
       serviceSetupCompletedHandled = true;
+      this.localServiceManifestInstanceInserted = true;
       if (options.cadenzaDB?.connect) {
         this.serviceRegistry.bootstrapFullSync(emit2, ctx, "service_setup_completed");
-        void this.publishServiceManifestIfNeeded(
-          "service_setup_completed",
-          "business_structural"
-        );
       }
+      this.maybeRequestInitialServiceManifestPublication(
+        "service_setup_completed",
+        "local_meta_structural"
+      );
+      this.scheduleInitialServiceManifestPublicationFallback(
+        "service_setup_completed",
+        "local_meta_structural"
+      );
       if (isFrontend) {
         registerActorSessionPersistenceTasks();
         this.ensureFrontendSyncLoop();
@@ -19927,6 +20748,9 @@ var CadenzaService = class {
       this.log("Service created.");
       return true;
     }).doOn("meta.service_registry.instance_inserted");
+    if (emitLocalServiceCreationImmediately) {
+      this.emit("meta.create_service_requested", initContext);
+    }
     if (!options.cadenzaDB?.connect) {
       Cadenza.schedule(
         "meta.service_registry.instance_registration_requested",
@@ -20391,6 +21215,30 @@ var CadenzaService = class {
     this.bootstrap();
     return Cadenza.createTask(name, func, description, options);
   }
+  static createHelper(name, func, description = "") {
+    this.bootstrap();
+    return Cadenza.createHelper(name, func, description);
+  }
+  static createMetaHelper(name, func, description = "") {
+    this.bootstrap();
+    return Cadenza.createMetaHelper(name, func, description);
+  }
+  static createHelperFromDefinition(definition) {
+    this.bootstrap();
+    return Cadenza.createHelperFromDefinition(definition);
+  }
+  static createGlobal(name, value, description = "") {
+    this.bootstrap();
+    return Cadenza.createGlobal(name, value, description);
+  }
+  static createMetaGlobal(name, value, description = "") {
+    this.bootstrap();
+    return Cadenza.createMetaGlobal(name, value, description);
+  }
+  static createGlobalFromDefinition(definition) {
+    this.bootstrap();
+    return Cadenza.createGlobalFromDefinition(definition);
+  }
   /**
    * Creates a meta task with the specified name, functionality, description, and options.
    * This is used for creating tasks that lives on the meta layer.
@@ -20727,6 +21575,7 @@ var CadenzaService = class {
     this.isBootstrapped = false;
     this.serviceCreated = false;
     this.bootstrapSyncCompleted = false;
+    this.bootstrapSyncCompletedAt = 0;
     this.bootstrapSignalRegistrationsCompleted = false;
     this.bootstrapIntentRegistrationsCompleted = false;
     this.defaultDatabaseServiceName = null;
@@ -20735,15 +21584,27 @@ var CadenzaService = class {
     this.frontendSyncScheduled = false;
     this.serviceManifestRevision = 0;
     this.lastPublishedServiceManifestHashes = {};
+    this.serviceManifestPublishedAt = {};
     this.serviceManifestPublicationInFlight = false;
     this.serviceManifestPublicationPendingReason = null;
     this.serviceManifestPublicationPendingLayer = null;
+    this.serviceManifestPublicationRetryReason = null;
+    this.serviceManifestPublicationRetryLayer = null;
+    if (this.serviceManifestPublicationRetryTimer) {
+      clearTimeout(this.serviceManifestPublicationRetryTimer);
+      this.serviceManifestPublicationRetryTimer = null;
+    }
+    this.serviceManifestPublicationRetryCount = 0;
+    this.localServiceManifestDefinitionInserted = false;
+    this.localServiceManifestInstanceInserted = false;
+    this.initialServiceManifestPublicationRequested = false;
     resetBrowserRuntimeActorHandles();
   }
 };
 CadenzaService.isBootstrapped = false;
 CadenzaService.serviceCreated = false;
 CadenzaService.bootstrapSyncCompleted = false;
+CadenzaService.bootstrapSyncCompletedAt = 0;
 CadenzaService.bootstrapSignalRegistrationsCompleted = false;
 CadenzaService.bootstrapIntentRegistrationsCompleted = false;
 CadenzaService.defaultDatabaseServiceName = null;
@@ -20752,9 +21613,17 @@ CadenzaService.hydratedInquiryResults = /* @__PURE__ */ new Map();
 CadenzaService.frontendSyncScheduled = false;
 CadenzaService.serviceManifestRevision = 0;
 CadenzaService.lastPublishedServiceManifestHashes = {};
+CadenzaService.serviceManifestPublishedAt = {};
 CadenzaService.serviceManifestPublicationInFlight = false;
 CadenzaService.serviceManifestPublicationPendingReason = null;
 CadenzaService.serviceManifestPublicationPendingLayer = null;
+CadenzaService.serviceManifestPublicationRetryReason = null;
+CadenzaService.serviceManifestPublicationRetryLayer = null;
+CadenzaService.serviceManifestPublicationRetryTimer = null;
+CadenzaService.serviceManifestPublicationRetryCount = 0;
+CadenzaService.localServiceManifestDefinitionInserted = false;
+CadenzaService.localServiceManifestInstanceInserted = false;
+CadenzaService.initialServiceManifestPublicationRequested = false;
 CadenzaService.shutdownHandlersRegistered = false;
 CadenzaService.shutdownInFlight = false;
 CadenzaService.shutdownHandlerCleanup = [];
@@ -20762,6 +21631,8 @@ CadenzaService.shutdownHandlerCleanup = [];
 // src/index.ts
 import {
   Actor as Actor2,
+  GlobalDefinition as GlobalDefinition2,
+  HelperDefinition as HelperDefinition2,
   DebounceTask as DebounceTask2,
   EphemeralTask as EphemeralTask2,
   GraphRoutine as GraphRoutine2,
@@ -21062,6 +21933,18 @@ var createTask = CadenzaService.createTask.bind(
 var createMetaTask = CadenzaService.createMetaTask.bind(
   CadenzaService
 );
+var createHelper = CadenzaService.createHelper.bind(
+  CadenzaService
+);
+var createMetaHelper = CadenzaService.createMetaHelper.bind(
+  CadenzaService
+);
+var createGlobal = CadenzaService.createGlobal.bind(
+  CadenzaService
+);
+var createMetaGlobal = CadenzaService.createMetaGlobal.bind(
+  CadenzaService
+);
 var createActor = CadenzaService.createActor.bind(
   CadenzaService
 );
@@ -21096,8 +21979,10 @@ export {
   DeputyTask,
   EXECUTION_PERSISTENCE_BUNDLE_SIGNAL,
   EphemeralTask2 as EphemeralTask,
+  GlobalDefinition2 as GlobalDefinition,
   GraphMetadataController,
   GraphRoutine2 as GraphRoutine,
+  HelperDefinition2 as HelperDefinition,
   RUNTIME_STATUS_AUTHORITY_SYNC_REQUESTED_SIGNAL,
   RUNTIME_VALIDATION_INTENTS,
   RUNTIME_VALIDATION_SIGNALS,
@@ -21117,6 +22002,10 @@ export {
   createCadenzaService,
   createDatabaseService,
   createExecutionPersistenceBundle,
+  createGlobal,
+  createHelper,
+  createMetaGlobal,
+  createMetaHelper,
   createMetaTask,
   createSSRInquiryBridge,
   createTask,